Android uygulamanızda Derinliği kullanma

Depth API, cihaz kamerasının bir sahnedeki gerçek nesnelerin boyutunu ve şeklini anlamasına yardımcı olur. Kamerayı kullanarak derinlikli görüntüler veya derinlik haritaları oluşturur. Böylece uygulamalarınıza artırılmış gerçeklik katmanı ekler. Sanal nesnelerin gerçek dünyadaki nesnelerin önünde veya arkasında doğru bir şekilde görünmesini sağlamak için derinlikli bir resmin sağladığı bilgileri kullanabilir, böylece sürükleyici ve gerçekçi bir kullanıcı deneyimi sağlayabilirsiniz.

Derinlik bilgileri hareketten hesaplanır ve varsa uçuş süresi (ToF) sensörü gibi bir donanım derinlik sensöründen gelen bilgilerle birleştirilebilir. Cihazların Depth API'yi desteklemek için ToF sensörü olması gerekmez.

Ön koşullar

Devam etmeden önce temel AR kavramlarını ve ARCore oturumunu nasıl yapılandıracağınızı anladığınızdan emin olun.

Derinliği destekleyen cihazlara erişimi kısıtlama

Uygulamanız, AR deneyiminin temel bir bölümü derinliğe dayalı olduğu veya uygulamanın derinlik kullanan bölümleri için sorunsuz bir yedek olmadığı için Depth API desteği gerektiriyorsa uygulamanızın Google Play Store'daki dağıtımını Depth API'yi destekleyen cihazlara aşağıdaki satırı ekleyerek kısıtlayabilirsiniz: Kılavuzda açıklanan ARCore değişikliklerinin yanı sıra AndroidManifest.xml'da açıklanan ARCore değişikliklerine ek olarak aşağıdaki satırı ekleyerek uygulamanızın Google Play Store'daAndroidManifest.xml

<uses-feature android:name="com.google.ar.core.depth" />

Derinliği Etkinleştir

Yeni bir ARCore oturumunda, kullanıcının cihazının Derinliği destekleyip desteklemediğini kontrol edin. ARCore uyumlu cihazların tümü, işlem gücü kısıtlamaları nedeniyle Depth API'yi desteklemez. Kaynakları kaydetmek için, derinlik ARCore'da varsayılan olarak devre dışı bırakılır. Uygulamanızın Depth API'yi kullanması için derinlik modunu etkinleştirin.

Java

Config config = session.getConfig();

// Check whether the user's device supports the Depth API.
boolean isDepthSupported = session.isDepthModeSupported(Config.DepthMode.AUTOMATIC);
if (isDepthSupported) {
  config.setDepthMode(Config.DepthMode.AUTOMATIC);
}
session.configure(config);

Kotlin

val config = session.config

// Check whether the user's device supports the Depth API.
val isDepthSupported = session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)
if (isDepthSupported) {
  config.depthMode = Config.DepthMode.AUTOMATIC
}
session.configure(config)

Derinlikli resimler edinme

Geçerli karenin derinlik resmini almak için Frame.acquireDepthImage16Bits() numaralı telefonu arayın.

Java

// Retrieve the depth image for the current frame, if available.
Image depthImage = null;
try {
  depthImage = frame.acquireDepthImage16Bits();
  // Use the depth image here.
} catch (NotYetAvailableException e) {
  // This means that depth data is not available yet.
  // Depth data will not be available if there are no tracked
  // feature points. This can happen when there is no motion, or when the
  // camera loses its ability to track objects in the surrounding
  // environment.
} finally {
  if (depthImage != null) {
    depthImage.close();
  }
}

Kotlin

// Retrieve the depth image for the current frame, if available.
try {
  frame.acquireDepthImage16Bits().use { depthImage ->
    // Use the depth image here.
  }
} catch (e: NotYetAvailableException) {
  // This means that depth data is not available yet.
  // Depth data will not be available if there are no tracked
  // feature points. This can happen when there is no motion, or when the
  // camera loses its ability to track objects in the surrounding
  // environment.
}

Döndürülen görüntü, işlenmemiş görüntü arabelleğini sağlar. Bu arabelleği, oluşturulacak her bir oluşturulmuş nesnenin GPU'da kullanımı için bir parça gölgelendiriciye geçirilebilir. OPENGL_NORMALIZED_DEVICE_COORDINATES hedeflenir ve Frame.transformCoordinates2d() çağrısı yapılarak TEXTURE_NORMALIZED olarak değiştirilebilir. Derinlik resmine bir nesne gölgelendiriciden erişildiğinde, bu derinlik ölçümlerine kapama işlemi için doğrudan erişilebilir.

Derinlik değerlerini anlama

Gözlemlenen gerçek geometrideki A noktası ve derinlik resminde aynı noktayı temsil eden 2D bir nokta a verildiğinde a'de Derinlik API'si tarafından verilen değer, ana eksene yansıtılan CA uzunluğuna eşittir. Bu, C kamera kaynağına göre A öğesinin z koordinatı olarak da adlandırılabilir. Depth API ile çalışırken derinlik değerlerinin CA ışınının uzunluğu değil, onun projeksiyonu olduğunu anlamak önemlidir.

Gölgelendiricilerde derinlik kullanma

Geçerli çerçeve için derinlik bilgilerini ayrıştırma

Geçerli ekran konumuna ilişkin derinlik bilgilerine erişmek için bir parça gölgelendiricide DepthGetMillimeters() ve DepthGetVisibility() yardımcı işlevlerini kullanın. Daha sonra, oluşturulan nesnenin belirli bölümlerini seçerek kapatmak için bu bilgileri kullanın.

// Use DepthGetMillimeters() and DepthGetVisibility() to parse the depth image
// for a given pixel, and compare against the depth of the object to render.
float DepthGetMillimeters(in sampler2D depth_texture, in vec2 depth_uv) {
  // Depth is packed into the red and green components of its texture.
  // The texture is a normalized format, storing millimeters.
  vec3 packedDepthAndVisibility = texture2D(depth_texture, depth_uv).xyz;
  return dot(packedDepthAndVisibility.xy, vec2(255.0, 256.0 * 255.0));
}

// Return a value representing how visible or occluded a pixel is relative
// to the depth image. The range is 0.0 (not visible) to 1.0 (completely
// visible).
float DepthGetVisibility(in sampler2D depth_texture, in vec2 depth_uv,
                         in float asset_depth_mm) {
  float depth_mm = DepthGetMillimeters(depth_texture, depth_uv);

  // Instead of a hard Z-buffer test, allow the asset to fade into the
  // background along a 2 * kDepthTolerancePerMm * asset_depth_mm
  // range centered on the background depth.
  const float kDepthTolerancePerMm = 0.015f;
  float visibility_occlusion = clamp(0.5 * (depth_mm - asset_depth_mm) /
    (kDepthTolerancePerMm * asset_depth_mm) + 0.5, 0.0, 1.0);

 // Use visibility_depth_near to set the minimum depth value. If using
 // this value for occlusion, avoid setting it too close to zero. A depth value
 // of zero signifies that there is no depth data to be found.
  float visibility_depth_near = 1.0 - InverseLerp(
      depth_mm, /*min_depth_mm=*/150.0, /*max_depth_mm=*/200.0);

  // Use visibility_depth_far to set the maximum depth value. If the depth
  // value is too high (outside the range specified by visibility_depth_far),
  // the virtual object may get inaccurately occluded at further distances
  // due to too much noise.
  float visibility_depth_far = InverseLerp(
      depth_mm, /*min_depth_mm=*/7500.0, /*max_depth_mm=*/8000.0);

  const float kOcclusionAlpha = 0.0f;
  float visibility =
      max(max(visibility_occlusion, kOcclusionAlpha),
          max(visibility_depth_near, visibility_depth_far));

  return visibility;
}

Sanal nesneleri kapat

Parça gölgelendiricinin gövdesindeki sanal nesneleri gizle. Nesnenin alfa kanalını derinliğine göre güncelleyin. Bu işlem, gizlenmiş bir nesneyi oluşturur.

// Occlude virtual objects by updating the object’s alpha channel based on its depth.
const float kMetersToMillimeters = 1000.0;

float asset_depth_mm = v_ViewPosition.z * kMetersToMillimeters * -1.;

// Compute the texture coordinates to sample from the depth image.
vec2 depth_uvs = (u_DepthUvTransform * vec3(v_ScreenSpacePosition.xy, 1)).xy;

gl_FragColor.a *= DepthGetVisibility(u_DepthTexture, depth_uvs, asset_depth_mm);

İki geçişli oluşturma veya nesne başına, ileri geçiş oluşturma özelliğini kullanarak kapama işlemini oluşturabilirsiniz. Her yaklaşımın verimliliği, sahnenin karmaşıklığına ve uygulamaya özgü diğer önemli noktalara bağlıdır.

Nesne bazında, ileri geçiş oluşturma

Nesne bazında, ileriye doğru oluşturma, malzeme gölgelendiricisindeki nesnenin her bir pikselinin kapsanmasını belirler. Pikseller görünmüyorsa, genellikle alfa karıştırma kullanılarak kırpılarak kullanıcının cihazında kapama simülasyonu yapılır.

İki geçişli oluşturma

İki geçişli oluşturmada ilk geçiş, sanal içeriğin tamamını bir ara arabelleğe dönüştürür. İkinci geçişte, gerçek dünya derinliği ile sanal sahne derinliği arasındaki fark temel alınarak sanal sahneyi arka planla harmanlar. Bu yaklaşım, nesneye özgü ek bir gölgelendirici çalışması gerektirmez ve genellikle ileriye doğru geçiş yönteminden daha düzgün görünen sonuçlar üretir.

Derinlikli bir resimden mesafeyi çıkarma

Depth API'yi sanal nesneleri gizlemek veya derinlik verilerini görselleştirmek dışında amaçlar için kullanmak istiyorsanız derinlik resimdeki bilgileri çıkarın.

Java

/** Obtain the depth in millimeters for depthImage at coordinates (x, y). */
public int getMillimetersDepth(Image depthImage, int x, int y) {
  // The depth image has a single plane, which stores depth for each
  // pixel as 16-bit unsigned integers.
  Image.Plane plane = depthImage.getPlanes()[0];
  int byteIndex = x * plane.getPixelStride() + y * plane.getRowStride();
  ByteBuffer buffer = plane.getBuffer().order(ByteOrder.nativeOrder());
  return Short.toUnsignedInt(buffer.getShort(byteIndex));
}

Kotlin

/** Obtain the depth in millimeters for [depthImage] at coordinates ([x], [y]). */
fun getMillimetersDepth(depthImage: Image, x: Int, y: Int): UInt {
  // The depth image has a single plane, which stores depth for each
  // pixel as 16-bit unsigned integers.
  val plane = depthImage.planes[0]
  val byteIndex = x * plane.pixelStride + y * plane.rowStride
  val buffer = plane.buffer.order(ByteOrder.nativeOrder())
  val depthSample = buffer.getShort(byteIndex)
  return depthSample.toUInt()
}

Kamera resimleri ile derinlik resimleri arasında koordinatları dönüştürme

getCameraImage() kullanılarak elde edilen resimler, derin resimlere kıyasla farklı bir en boy oranına sahip olabilir. Bu durumda derinlik resmi, kamera görüntüsünün bir kısmıdır ve kamera resmindeki tüm piksellere karşılık gelen geçerli bir derinlik tahmini yoktur.

CPU görüntüsü üzerindeki koordinatların derinlik resim koordinatlarını almak için:

Java

float[] cpuCoordinates = new float[] {cpuCoordinateX, cpuCoordinateY};
float[] textureCoordinates = new float[2];
frame.transformCoordinates2d(
    Coordinates2d.IMAGE_PIXELS,
    cpuCoordinates,
    Coordinates2d.TEXTURE_NORMALIZED,
    textureCoordinates);
if (textureCoordinates[0] < 0 || textureCoordinates[1] < 0) {
  // There are no valid depth coordinates, because the coordinates in the CPU image are in the
  // cropped area of the depth image.
  return null;
}
return new Pair<>(
    (int) (textureCoordinates[0] * depthImage.getWidth()),
    (int) (textureCoordinates[1] * depthImage.getHeight()));

Kotlin

val cpuCoordinates = floatArrayOf(cpuCoordinateX.toFloat(), cpuCoordinateY.toFloat())
val textureCoordinates = FloatArray(2)
frame.transformCoordinates2d(
  Coordinates2d.IMAGE_PIXELS,
  cpuCoordinates,
  Coordinates2d.TEXTURE_NORMALIZED,
  textureCoordinates,
)
if (textureCoordinates[0] < 0 || textureCoordinates[1] < 0) {
  // There are no valid depth coordinates, because the coordinates in the CPU image are in the
  // cropped area of the depth image.
  return null
}
return (textureCoordinates[0] * depthImage.width).toInt() to
  (textureCoordinates[1] * depthImage.height).toInt()

Derinlik resim koordinatları için CPU resim koordinatlarını almak üzere:

Java

float[] textureCoordinates =
    new float[] {
      (float) depthCoordinateX / (float) depthImage.getWidth(),
      (float) depthCoordinateY / (float) depthImage.getHeight()
    };
float[] cpuCoordinates = new float[2];
frame.transformCoordinates2d(
    Coordinates2d.TEXTURE_NORMALIZED,
    textureCoordinates,
    Coordinates2d.IMAGE_PIXELS,
    cpuCoordinates);
return new Pair<>((int) cpuCoordinates[0], (int) cpuCoordinates[1]);

Kotlin

val textureCoordinates =
  floatArrayOf(
    depthCoordinatesX.toFloat() / depthImage.width.toFloat(),
    depthCoordinatesY.toFloat() / depthImage.height.toFloat(),
  )
val cpuCoordinates = FloatArray(2)
frame.transformCoordinates2d(
  Coordinates2d.TEXTURE_NORMALIZED,
  textureCoordinates,
  Coordinates2d.IMAGE_PIXELS,
  cpuCoordinates,
)
return cpuCoordinates[0].toInt() to cpuCoordinates[1].toInt()

Derinlik isabet testi

İsabet testleri kullanıcıların nesneleri sahnede gerçek bir konuma yerleştirmesine olanak tanır. Daha önce isabet testleri yalnızca algılanan düzlemlerde yürütülebiliyordu ve bu testler, yeşil Android'lerin gösterdiği sonuçlar gibi büyük ve düz yüzeylerle sınırlıydı. Derinlik isabet testleri, düzlemsel olmayan ve düşük dokulu yüzeylerde bile daha doğru isabet sonuçları sağlamak için hem düzgün hem de ham derinlik bilgisinden yararlanır. Bu simge kırmızı Android'lerle gösterilmektedir.

Derinlik özellikli isabet testlerini kullanmak için hitTest() yöntemini çağırın ve döndürülen listede DepthPoints olup olmadığını kontrol edin.

Java

// Create a hit test using the Depth API.
List<HitResult> hitResultList = frame.hitTest(tap);
for (HitResult hit : hitResultList) {
  Trackable trackable = hit.getTrackable();
  if (trackable instanceof Plane
      || trackable instanceof Point
      || trackable instanceof DepthPoint) {
    useHitResult(hit);
    break;
  }
}

Kotlin

// Create a hit test using the Depth API.
val hitResult =
  frame
    .hitTest(tap)
    .filter {
      val trackable = it.trackable
      trackable is Plane || trackable is Point || trackable is DepthPoint
    }
    .firstOrNull()
useHitResult(hitResult)

Sonraki adımlar