Android uygulamanızda Derinliği kullanma

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

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

Ön koşullar

Temel artırılmış gerçeklik kavramlarını anladığınızdan emin olun ve devam etmeden önce ARCore oturumunun nasıl yapılandırılacağı hakkında daha fazla bilgi edinin.

Derinlik destekli cihazlara erişimi kısıtlayın

Uygulamanız, Artırılmış gerçeklik (AR) deneyimi derinliğe dayalı olduğundan ya da derinlik kullanan kısımları varsa bunların dağıtımını kısıtlamayı Google Play Store'daki Depth API'yi destekleyen cihazlara eklemek için aşağıdaki satıra ek olarak, AndroidManifest.xml AndroidManifest.xml değişiklik ARCore'u etkinleştirme rehberi:

<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. İşlem gücü kısıtlamaları nedeniyle ARCore uyumlu cihazların hepsi Depth API'yi desteklemez. Kaynaklardan tasarruf etmek için ARCore'da derinlik varsayılan olarak devre dışıdır. Uygulamanızın Depth API'yi kullanması için derinlik modunu etkinleştirin.

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);

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 görüntüler edinme

Geçerli karenin derinlik görüntüsünü almak için Frame.acquireDepthImage16Bits() numaralı telefonu arayın.

// 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();
  }
}

// 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ü, ham resim arabelleğini sağlar. Bu arabellek, işlenecek her bir nesne için GPU'da kullanılmak üzere parça gölgelendiriciye geçirilebilir. OPENGL_NORMALIZED_DEVICE_COORDINATES ülkesindedir ve Frame.transformCoordinates2d() çağrısı yapılarak TEXTURE_NORMALIZED olarak değiştirilebilir. Derinlik resmine nesne gölgelendirici içinde erişildiğinde kapama işleme için bu derinlik ölçümlerine doğrudan erişilebilir.

Derinlik değerlerini anlama

Gözlemlenen gerçek dünya geometrisinde A noktası ve 2D a noktası verilir. derinlik resminde aynı noktayı temsil eden, Derinlik a konumundaki API, ana eksene tahmin edilen CA uzunluğuna eşit. Bu, kameraya göre A işlevinin z koordinatı olarak da adlandırılabilir kaynak: C. Depth API ile çalışırken, makine öğreniminin derinlik değerleri ışınının CA uzunluğu değil, projeksiyon öğreneceğiz.

Gölgelendiricilerde derinlik kullan

Geçerli kare için derinlik bilgilerini ayrıştır

Geçerli ekran konumunun derinlik bilgilerine erişmek için parça gölgelendiricide DepthGetMillimeters() ve DepthGetVisibility() yardımcı işlevlerini kullanın. Daha sonra, bu bilgileri kullanarak oluşturulan nesnenin bazı bölümlerini seçmeli olarak kapatı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 kaplama

Sanal nesneleri parça gölgelendiricinin gövdesinde tutun. Nesnenin alfa kanalını derinliğine göre günceller. Bu işlem, kapalı 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);

Kapatmayı iki geçişli oluşturmayı veya nesne başına, ileri geçişli oluşturmayı kullanarak oluşturabilirsiniz. Her yaklaşımın verimliliği, sahnenin karmaşıklığına ve uygulamaya özgü diğer hususlara bağlıdır.

Nesne başına, ileriye dönük oluşturma

Nesne başına ileri geçiş oluşturma, malzeme gölgelendiricisinde nesnenin her pikselinin kapsanmasını belirler. Pikseller görünmüyorsa genellikle alfa karıştırma ile kırpılır ve böylece kullanıcının cihazında tıkanma 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ı ara arabelleğe alı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 birleştiriyor. Bu yaklaşım, nesneye özel ek gölgelendirici çalışması gerektirmez ve genellikle ileri geçiş yönteminden daha tek tip görünümlü sonuçlar üretir.

Derinlik görüntüsünden mesafeyi ayıkla

Depth API'yi sanal nesneleri kapatma veya derinlik verilerini görselleştirme dışında başka amaçlarla kullanmak için derinlik görüntüsündeki bilgileri ayıklayın.

/** 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));
}

/** 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 görüntüleri ile derinlikli görüntüler arasındaki koordinatları dönüştürme

getCameraImage() kullanılarak elde edilen görüntülerin en boy oranları, derinlikli resimlere göre farklı olabilir. Bu durumda derinlik resmi, kamera görüntüsünün kesilmesidir ve kamera görüntüsündeki tüm piksellere karşılık gelen geçerli bir derinlik tahmini yoktur.

CPU görüntüsü üzerindeki koordinatlara ilişkin derinlik görüntü koordinatlarını almak için:

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()));

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 görüntü koordinatlarını almak üzere:

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]);

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 sahnedeki gerçek bir konuma yerleştirmesine olanak tanır. Daha önce, isabet testleri yalnızca algılanan uçaklarda yürütülebiliyor ve konumları yeşil Android'lerin gösterdiği sonuçlar gibi büyük, düz yüzeylerle sınırlandırıyordu. 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 bilgilerinden yararlanır. Bu simge, kırmızı Android ile gösteriliyor.

Derinlik etkin isabet testlerini kullanmak için hitTest() numaralı telefonu arayın ve dönüş listesinde DepthPoints olup olmadığını kontrol edin.

// 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;
  }
}

// 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)

Sırada ne var?

• Raw Depth API ile daha doğru algılama sağlayın.
• Derinlik verilerine erişmenin farklı yollarını gösteren ARCore Depth Lab'e göz atın.