Utiliser la profondeur brute dans votre application Android

L'API Raw Depth fournit des données de profondeur pour une image d'appareil photo dont la précision est supérieure à celle des données complètes de l'API Depth, mais elle ne couvre pas toujours tous les pixels. Les images de profondeur brutes, ainsi que les images de confiance correspondantes, peuvent également être traitées plus en détail, ce qui permet aux applications d'utiliser uniquement les données de profondeur dont la précision est suffisante pour leur cas d'utilisation individuel.

Compatibilité avec les appareils

Elle est disponible sur tous les appareils compatibles avec l'API Depth. L'API Raw Depth, comme l'API Depth complète, ne nécessite pas de capteur de profondeur matériel compatible, tel qu'un capteur de durée de vol (ToF). Toutefois, les API Raw Depth et Full Depth utilisent toutes les deux tous les capteurs matériels compatibles d'un appareil.

Comparaison entre l'API Raw Depth et l'API Full Depth

L'API Raw Depth fournit des estimations de profondeur avec une plus grande précision, mais les images de profondeur brutes peuvent ne pas inclure d'estimations de profondeur pour tous les pixels de l'image de l'appareil photo. En revanche, l'API Full Depth fournit une estimation de la profondeur pour chaque pixel. Toutefois, les données de profondeur par pixel peuvent être moins précises en raison du lissage et de l'interpolation des estimations de profondeur. Le format et la taille des représentations de profondeur sont identiques dans les deux API. Seul le contenu diffère.

Le tableau suivant illustre les différences entre l'API Raw Depth et l'API Full Depth à l'aide d'une image d'une chaise et d'une table dans une cuisine.

API Renvoie Image de l'appareil photo Image de profondeur Image de confiance
API Raw Depth
  • Image de profondeur brute qui contient une estimation très précise de la profondeur pour certains pixels de l'image de l'appareil photo, mais pas pour tous.
  • Image de confiance qui donne l'indice de confiance de chaque pixel d'image de profondeur brut. Le niveau de confiance des pixels de l'image de l'appareil photo sans estimation de la profondeur est de zéro.
API Full Depth
  • Un single "lissé" une image de profondeur qui contient une estimation de la profondeur pour chaque pixel.
  • Aucune image de confiance n'est fournie avec cette API.
 N/A

Images de confiance

Dans les images de confiance renvoyées par l'API Raw Depth, les pixels plus clairs ont des valeurs de confiance plus élevées, les pixels blancs représentant un niveau de confiance total et les pixels noirs un degré de confiance élevé. En général, les zones de l'image de l'appareil photo qui présentent le plus de texture (un arbre, par exemple) ont une confiance en la profondeur brute supérieure à celle des autres zones, comme un mur blanc. Les surfaces sans texture donnent généralement un indice de confiance de zéro.

Si l'appareil cible est équipé d'un capteur de profondeur compatible, les zones de l'image suffisamment proches de l'appareil photo seront probablement plus fiables, même sur des surfaces sans texture.

Coût de calcul

Le coût de calcul de l'API Raw Depth correspond à environ la moitié du coût de calcul de l'API Depth complète.

Cas d'utilisation

L'API Raw Depth vous permet d'obtenir des représentations de profondeur qui fournissent une représentation plus détaillée de la géométrie des objets de la scène. Les données de profondeur brutes peuvent être utiles pour créer des expériences de RA qui nécessitent davantage de précision et de détails pour les tâches de compréhension de la géométrie. Voici quelques cas d'utilisation :

  • Reconstruction 3D
  • Mesure
  • Détection de formes

Prérequis

Assurez-vous de bien maîtriser les concepts fondamentaux de la RA. et comment configurer une session ARCore avant de continuer.

Activer la profondeur

Dans une nouvelle session ARCore, vérifiez si l'appareil de l'utilisateur est compatible avec la fonctionnalité de profondeur. Les appareils compatibles ARCore ne sont pas tous compatibles avec l'API Depth en raison de contraintes de puissance de traitement. Pour économiser des ressources, la profondeur est désactivée par défaut sur ARCore. Activez le mode Profondeur pour que votre application utilise l'API Depth.

Java

Config config = session.getConfig();

// Check whether the user's device supports Depth.
if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {
  // Enable depth mode.
  config.setDepthMode(Config.DepthMode.AUTOMATIC);
}
session.configure(config);

Kotlin

if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {
  session.configure(session.config.apply { depthMode = Config.DepthMode.AUTOMATIC })
}

Obtenez les dernières images brutes de profondeur et de confiance

Appelez frame.acquireRawDepthImage16Bits() pour obtenir la dernière représentation de profondeur brute. Les pixels d'image renvoyés par l'API Raw Depth ne contiennent pas tous des données de profondeur, et les images ARCore ne contiennent pas toutes une nouvelle image de profondeur brute. Pour déterminer si la représentation de profondeur brute de l'image actuelle est nouvelle, comparez son code temporel à celui de la précédente image de profondeur brute. Si les codes temporels sont différents, l'image de profondeur brute est basée sur les nouvelles données de profondeur. Sinon, la représentation de profondeur est une reprojection des données de profondeur précédentes.

Appelez frame.acquireRawDepthConfidenceImage() pour obtenir l'image de confiance. Vous pouvez utiliser l'image de confiance pour vérifier la précision de chaque pixel de profondeur brut. Les images de confiance sont renvoyées au format Y8. Chaque pixel est un entier non signé de 8 bits. 0 indique le niveau de confiance le plus faible, tandis que 255 indique le niveau de confiance le plus élevé.

Java

// Use try-with-resources, so that images are released automatically.
try (
// Depth image is in uint16, at GPU aspect ratio, in native orientation.
Image rawDepth = frame.acquireRawDepthImage16Bits();
    // Confidence image is in uint8, matching the depth image size.
    Image rawDepthConfidence = frame.acquireRawDepthConfidenceImage(); ) {
  // Compare timestamps to determine whether depth is is based on new
  // depth data, or is a reprojection based on device movement.
  boolean thisFrameHasNewDepthData = frame.getTimestamp() == rawDepth.getTimestamp();
  if (thisFrameHasNewDepthData) {
    ByteBuffer depthData = rawDepth.getPlanes()[0].getBuffer();
    ByteBuffer confidenceData = rawDepthConfidence.getPlanes()[0].getBuffer();
    int width = rawDepth.getWidth();
    int height = rawDepth.getHeight();
    someReconstructionPipeline.integrateNewImage(depthData, confidenceData, width, height);
  }
} catch (NotYetAvailableException e) {
  // Depth image is not (yet) available.
}

Kotlin

try {
  // Depth image is in uint16, at GPU aspect ratio, in native orientation.
  frame.acquireRawDepthImage16Bits().use { rawDepth ->
    // Confidence image is in uint8, matching the depth image size.
    frame.acquireRawDepthConfidenceImage().use { rawDepthConfidence ->
      // Compare timestamps to determine whether depth is is based on new
      // depth data, or is a reprojection based on device movement.
      val thisFrameHasNewDepthData = frame.timestamp == rawDepth.timestamp
      if (thisFrameHasNewDepthData) {
        val depthData = rawDepth.planes[0].buffer
        val confidenceData = rawDepthConfidence.planes[0].buffer
        val width = rawDepth.width
        val height = rawDepth.height
        someReconstructionPipeline.integrateNewImage(
          depthData,
          confidenceData,
          width = width,
          height = height
        )
      }
    }
  }
} catch (e: NotYetAvailableException) {
  // Depth image is not (yet) available.
}

Étapes suivantes