Utilizzare la profondità grezza nell'app per Android

L'API Raw Depth fornisce dati di profondità per un'immagine della fotocamera con una precisione superiore rispetto ai dati dell'API Full Depth, ma non sempre copre ogni pixel. Anche le immagini di profondità non elaborate, insieme alle immagini di affidabilità corrispondenti, possono essere elaborate ulteriormente, consentendo alle app di usare solo i dati di profondità con una precisione sufficiente per il loro caso d'uso individuale.

Compatibilità del dispositivo

La profondità non elaborata è disponibile su tutti i dispositivi che supportano l'API Depth. L'API Raw Depth, come l'API Full Depth, non richiede un sensore di profondità hardware supportato, come un sensore del tempo di volo (ToF). Tuttavia, sia l'API Raw Depth sia l'API Full Depth utilizzano gli eventuali sensori hardware supportati di un dispositivo.

API Raw Depth e API Full Depth

L'API Raw Depth fornisce stime della profondità con maggiore precisione, ma le immagini di profondità non elaborate potrebbero non includere le stime della profondità per tutti i pixel nell'immagine della fotocamera. Al contrario, l'API Full Depth fornisce una stima della profondità per ogni pixel, ma i dati sulla profondità per pixel potrebbero essere meno precisi a causa del livellamento e dell'interpolazione delle stime della profondità. Il formato e la dimensione delle immagini di profondità sono gli stessi in entrambe le API. ma solo i contenuti sono diversi.

La tabella seguente illustra le differenze tra l'API Raw Depth e l'API Full Depth utilizzando l'immagine di una sedia e un tavolo in una cucina.

API Resi Immagine fotocamera Immagine profondità Immagine di confidenza
API Raw Depth
  • Un'immagine di profondità non elaborata contenente una stima molto precisa della profondità per alcuni pixel (ma non tutti) nell'immagine della fotocamera.
  • Un'immagine attendibile che dà fiducia per ogni pixel dell'immagine di profondità non elaborata. I pixel dell'immagine della fotocamera senza una stima della profondità hanno un valore di confidenza pari a zero.
API Full Depth
  • Un singolo "levato" un'immagine di profondità che contiene una stima della profondità per ogni pixel.
  • Questa API non fornisce alcuna immagine di confidenza.
 N/D

Immagini di confidenza

In termini di confidenza delle immagini restituite dall'API Raw Depth, i pixel più chiari hanno valori di confidenza più elevati, con i pixel bianchi che rappresentano la confidenza completa e i pixel neri rappresentano la mancanza di confidenza. In generale, le regioni nell'immagine della fotocamera che hanno una maggiore texture, ad esempio un albero, avranno una confidenza di profondità non elaborata più elevata rispetto alle regioni che non lo hanno, ad esempio un muro vuoto. In genere, le superfici senza consistenza hanno una confidenza pari a zero.

Se il dispositivo target è dotato di un sensore di profondità hardware supportato, l'affidabilità delle aree dell'immagine abbastanza vicine alla fotocamera sarà probabilmente più elevata, anche sulle superfici senza texture.

Costo calcolo

Il costo di calcolo dell'API Raw Depth è circa la metà di quello dell'API Full Depth.

Casi d'uso

Con l'API Raw Depth puoi ottenere immagini di profondità che forniscono una rappresentazione più dettagliata della geometria degli oggetti nella scena. I dati di profondità non elaborati possono essere utili durante la creazione di esperienze AR in cui sono necessari una maggiore precisione e dettagli della profondità per attività di comprensione della geometria. Alcuni casi d'uso includono:

  • Ricostruzione 3D
  • Misurazione
  • Rilevamento della forma

Prerequisiti

Assicurati di comprendere i concetti fondamentali della realtà aumentata e su come configurare una sessione ARCore prima di procedere.

Attiva profondità

In una nuova sessione ARCore, controlla se il dispositivo di un utente supporta la profondità. Non tutti i dispositivi compatibili con ARCore supportano l'API Depth a causa di limitazioni della potenza di elaborazione. Per risparmiare risorse, la profondità è disattivata per impostazione predefinita su ARCore. Attiva la modalità depth per fare in modo che la tua app usi 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 })
}

Acquisisci le più recenti immagini di affidabilità e profondità non elaborate

Chiama frame.acquireRawDepthImage16Bits() per acquisire l'ultima immagine di profondità non elaborata. Non tutti i pixel immagine restituiti tramite l'API Raw Depth conterranno dati di profondità e non tutti i frame ARCore conterranno una nuova immagine di profondità non elaborata. Per determinare se l'immagine di profondità non elaborata per il frame corrente è nuova, confronta il timestamp con il timestamp dell'immagine di profondità non elaborata precedente. Se i timestamp sono diversi, l'immagine di profondità non elaborata si basa su nuovi dati di profondità. In caso contrario, l'immagine di profondità è una riproiezione di dati di profondità precedenti.

Chiama frame.acquireRawDepthConfidenceImage() per acquisire l'immagine di affidabilità. Puoi utilizzare l'immagine di confidenza per verificare la precisione di ogni pixel di profondità non elaborato. Le immagini di confidenza vengono restituite nel formato Y8. Ogni pixel è un numero intero senza segno a 8 bit. 0 indica l'affidabilità minima, mentre 255 indica la massima affidabilità.

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.
}

Passaggi successivi