Sử dụng Chiều sâu trong ứng dụng Android NDK

Depth API giúp máy ảnh của thiết bị hiểu được kích thước và hình dạng của các vật thể thực trong một cảnh. Tính năng này sử dụng camera để tạo hình ảnh chiều sâu hay bản đồ độ sâu, do đó thêm một lớp hiện thực AR vào ứng dụng của bạn. Bạn có thể sử dụng thông tin do hình ảnh độ sâu cung cấp để các đối tượng ảo xuất hiện chính xác ở phía trước hoặc phía sau các đối tượng trong thế giới thực, mang đến trải nghiệm sống động và chân thực cho người dùng.

Thông tin về độ sâu được tính toán từ chuyển động và có thể được kết hợp với thông tin từ cảm biến độ sâu phần cứng, chẳng hạn như cảm biến thời gian bay (ToF), nếu có. Thiết bị không cần có cảm biến ToF để hỗ trợ depth API.

Điều kiện tiên quyết

Đảm bảo rằng bạn hiểu rõ các khái niệm cơ bản về AR và cách định cấu hình phiên ARCore trước khi tiếp tục.

Chỉ cho phép những thiết bị hỗ trợ tính năng Chiều sâu

Nếu ứng dụng của bạn cần hỗ trợ API Độ sâu, do một phần cốt lõi của Trải nghiệm thực tế tăng cường phụ thuộc vào chiều sâu hoặc do không có phương án dự phòng phù hợp cho cho các phần của ứng dụng sử dụng chiều sâu, bạn có thể chọn hạn chế phân phối trong Cửa hàng Google Play để những thiết bị hỗ trợ depth API bằng cách thêm dòng sau vào AndroidManifest.xml của bạn, ngoài việc AndroidManifest.xml thay đổi được mô tả trong Hướng dẫn Bật ARCore:

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

Bật tính năng Chiều sâu

Trong phiên ARCore mới, hãy kiểm tra xem thiết bị của người dùng có hỗ trợ Chiều sâu hay không. Không phải thiết bị nào tương thích với ARCore đều hỗ trợ Depth API do hạn chế về sức mạnh xử lý. Để tiết kiệm tài nguyên, theo mặc định, độ sâu sẽ bị tắt trên ARCore. Bật chế độ chiều sâu để ứng dụng sử dụng depth API.

// Check whether the user's device supports the Depth API.
int32_t is_depth_supported = 0;
ArSession_isDepthModeSupported(ar_session, AR_DEPTH_MODE_AUTOMATIC,
                               &is_depth_supported);

// Configure the session for AR_DEPTH_MODE_AUTOMATIC.
ArConfig* ar_config = NULL;
ArConfig_create(ar_session, &ar_config);
if (is_depth_supported) {
  ArConfig_setDepthMode(ar_session, ar_config, AR_DEPTH_MODE_AUTOMATIC);
}
CHECK(ArSession_configure(ar_session, ar_config) == AR_SUCCESS);
ArConfig_destroy(ar_config);

Thu thập hình ảnh có độ sâu

Gọi ArFrame_acquireDepthImage16Bits() để lấy hình ảnh chiều sâu cho khung hình hiện tại.

// Retrieve the depth image for the current frame, if available.
ArImage* depth_image = NULL;
// If a depth image is available, use it here.
if (ArFrame_acquireDepthImage16Bits(ar_session, ar_frame, &depth_image) !=
    AR_SUCCESS) {
  // No depth image received for this frame.
  // This normally 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.
  return;
}

Hình ảnh được trả về cung cấp vùng đệm hình ảnh thô. Vùng đệm này có thể được truyền đến chương trình đổ bóng mảnh để sử dụng trên GPU cho từng đối tượng kết xuất cần che khuất. Thuộc tính này được định hướng trong AR_COORDINATES_2D_OPENGL_NORMALIZED_DEVICE_COORDINATES và có thể được thay đổi thành AR_COORDINATES_2D_TEXTURE_NORMALIZED bằng cách gọi ArFrame_transformCoordinates2d(). Khi có thể truy cập hình ảnh chiều sâu trong chương trình đổ bóng đối tượng, bạn có thể truy cập trực tiếp các số đo chiều sâu này để xử lý sự cố che khuất.

Tìm hiểu về giá trị chiều sâu

Cho điểm A trên hình học thực tế đã quan sát và điểm 2D a đại diện cho cùng một điểm trong hình ảnh chiều sâu, giá trị được cho bởi Độ sâu API tại a bằng độ dài của CA được chiếu lên trục chính. Đây cũng có thể được gọi là toạ độ z của A so với camera máy chủ gốc C. Khi làm việc với Depth API, điều quan trọng là bạn phải hiểu rằng các giá trị chiều sâu không phải là chiều dài của tia CA mà là phương diện của tia đó.

Sử dụng độ sâu trong chương trình đổ bóng

Phân tích cú pháp thông tin về chiều sâu của khung hình hiện tại

Sử dụng các hàm trợ giúp DepthGetMillimeters() và DepthGetVisibility() trong chương trình đổ bóng mảnh để truy cập vào thông tin chuyên sâu cho vị trí màn hình hiện tại. Sau đó, hãy dùng thông tin này để che khuất có chọn lọc các phần của đối tượng được kết xuất.

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

Che khuất các đối tượng ảo

Phủ các đối tượng ảo trong phần nội dung của chương trình đổ bóng mảnh. Cập nhật kênh alpha của đối tượng dựa trên độ sâu của kênh. Thao tác này sẽ kết xuất một đối tượng bị che khuất.

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

Bạn có thể kết xuất che khuất bằng cách sử dụng kết xuất hai chiều hoặc kết xuất theo từng đối tượng, kết xuất chuyển tiếp. Hiệu quả của mỗi phương pháp phụ thuộc vào mức độ phức tạp của cảnh và các yếu tố khác cần cân nhắc dành riêng cho ứng dụng.

Kết xuất chuyển tiếp theo từng đối tượng

Tính năng kết xuất theo từng đối tượng xác định độ che khuất từng pixel của đối tượng trong chương trình đổ bóng chất liệu. Nếu pixel không hiển thị, thì chúng sẽ bị cắt bớt, thường là bằng cách phối màu alpha, nhờ đó mô phỏng hình ảnh bị che khuất trên thiết bị của người dùng.

Kết xuất hai lần

Với tính năng kết xuất hai lượt, lượt truyền đầu tiên sẽ kết xuất tất cả nội dung ảo vào một vùng đệm trung gian. Lần kết hợp thứ hai sẽ kết hợp cảnh ảo vào nền dựa trên sự khác biệt giữa độ sâu thực tế với độ sâu của cảnh ảo. Phương pháp này không yêu cầu thêm công việc đổ bóng dành riêng cho đối tượng và thường tạo ra kết quả trông đồng nhất hơn so với phương thức truyền thẳng.

Chuyển đổi toạ độ giữa hình ảnh máy ảnh và hình ảnh chiều sâu

Hình ảnh thu được bằng ArFrame_acquireCameraImage() có thể có tỷ lệ khung hình khác so với hình ảnh chiều sâu. Trong trường hợp này, hình ảnh chiều sâu là phần cắt của hình ảnh camera và không phải tất cả pixel trong hình ảnh camera đều có số liệu ước tính độ sâu hợp lệ tương ứng.

Cách lấy toạ độ hình ảnh độ sâu cho toạ độ trên hình ảnh CPU:

const float cpu_image_coordinates[] = {(float)cpu_coordinate_x,
                                 (float)cpu_coordinate_y};
float texture_coordinates[2];
ArFrame_transformCoordinates2d(
    ar_session, ar_frame, AR_COORDINATES_2D_IMAGE_PIXELS, 1,
    cpu_image_coordinates, AR_COORDINATES_2D_TEXTURE_NORMALIZED,
    texture_coordinates);
if (texture_coordinates[0] < 0 || texture_coordinates[1] < 0) {
  // There are no valid depth coordinates, because the coordinates in the CPU
  // image are in the cropped area of the depth image.
} else {
  int depth_image_width = 0;
  ArImage_getWidth(ar_session, depth_image, &depth_image_width);
  int depth_image_height = 0;
  ArImage_getHeight(ar_session, depth_image, &depth_image_height);

  int depth_coordinate_x = (int)(texture_coordinates[0] * depth_image_width);
  int depth_coordinate_y = (int)(texture_coordinates[1] * depth_image_height);
}

Để lấy toạ độ hình ảnh CPU cho toạ độ hình ảnh chiều sâu:

int depth_image_width = 0;
ArImage_getWidth(ar_session, depth_image, &depth_image_width);
int depth_image_height = 0;
ArImage_getHeight(ar_session, depth_image, &depth_image_height);

float texture_coordinates[] = {
    (float)depth_coordinate_x / (float)depth_image_width,
    (float)depth_coordinate_y / (float)depth_image_height};
float cpu_image_coordinates[2];
ArFrame_transformCoordinates2d(
    ar_session, ar_frame, AR_COORDINATES_2D_TEXTURE_NORMALIZED, 1,
    texture_coordinates, AR_COORDINATES_2D_IMAGE_PIXELS,
    cpu_image_coordinates);

int cpu_image_coordinate_x = (int)cpu_image_coordinates[0];
int cpu_image_coordinate_y = (int)cpu_image_coordinates[1];

Kiểm tra mức độ tác động sâu

Kiểm thử lượt truy cập cho phép người dùng đặt đối tượng tại vị trí thực tế trong cảnh. Trước đây, bạn chỉ có thể tiến hành kiểm thử lượt nhấn trên các mặt phẳng đã phát hiện, giới hạn vị trí ở các bề mặt lớn, phẳng, chẳng hạn như kết quả hiển thị bằng Android màu xanh lục. Kiểm tra lượt truy cập chuyên sâu tận dụng cả thông tin chiều sâu mượt mà lẫn thông tin chiều sâu thô để cung cấp kết quả lượt truy cập chính xác hơn, ngay cả trên bề mặt không phải là hai chiều phẳng và có kết cấu thấp. Điều này được thể hiện với Android màu đỏ.

Để sử dụng thử nghiệm lượt truy cập có kích hoạt chiều sâu, hãy gọi ArFrame_hitTest() và kiểm tra các AR_TRACKABLE_DEPTH_POINT trong danh sách trả về.

// Create a hit test using the Depth API.
ArHitResultList* hit_result_list = NULL;
ArHitResultList_create(ar_session, &hit_result_list);
ArFrame_hitTest(ar_session, ar_frame, hit_x, hit_y, hit_result_list);

int32_t hit_result_list_size = 0;
ArHitResultList_getSize(ar_session, hit_result_list, &hit_result_list_size);

ArHitResult* ar_hit_result = NULL;
for (int32_t i = 0; i < hit_result_list_size; ++i) {
  ArHitResult* ar_hit = NULL;
  ArHitResult_create(ar_session, &ar_hit);
  ArHitResultList_getItem(ar_session, hit_result_list, i, ar_hit);

  ArTrackable* ar_trackable = NULL;
  ArHitResult_acquireTrackable(ar_session, ar_hit, &ar_trackable);
  ArTrackableType ar_trackable_type = AR_TRACKABLE_NOT_VALID;
  ArTrackable_getType(ar_session, ar_trackable, &ar_trackable_type);
  // Creates an anchor if a plane or an oriented point was hit.
  if (AR_TRACKABLE_DEPTH_POINT == ar_trackable_type) {
    // Do something with the hit result.
  }
  ArTrackable_release(ar_trackable);
  ArHitResult_destroy(ar_hit);
}

ArHitResultList_destroy(hit_result_list);

Bước tiếp theo