Raw Depth API จะให้ข้อมูลความลึกสำหรับรูปจากกล้องที่มีความแม่นยำสูงกว่าข้อมูล Depth API แบบเต็มรูปแบบ แต่อาจไม่ได้ครอบคลุมทุกพิกเซลเสมอไป นอกจากนี้ ระบบยังประมวลผลรูปภาพเชิงลึก รวมถึงรูปภาพความเชื่อมั่นที่ตรงกันได้ด้วย เพื่ออนุญาตให้แอปใช้เฉพาะข้อมูลความลึกที่แม่นยําเพียงพอสําหรับกรณีการใช้งานแต่ละรายการ
ความเข้ากันได้ของอุปกรณ์
ความลึกของข้อมูลดิบพร้อมใช้งานในอุปกรณ์ที่รองรับ Depth API ทั้งหมด Raw Depth API เหมือนกับ API ความลึกเต็มรูปแบบ ไม่จำเป็นต้องใช้เซ็นเซอร์วัดความลึกของฮาร์ดแวร์ที่รองรับ เช่น เซ็นเซอร์ Time of Flight (ToF) อย่างไรก็ตาม ทั้ง Raw Depth API และ API ความลึกเต็มรูปแบบจะใช้เซ็นเซอร์ของฮาร์ดแวร์ที่รองรับทั้งหมดที่อุปกรณ์อาจมี
Raw Depth API กับ Full Depth API
Raw Depth API จะแสดงค่าประมาณความลึกที่มีความแม่นยำสูงกว่า แต่รูปภาพความลึกแบบข้อมูลดิบอาจไม่รวมค่าประมาณความลึกสําหรับพิกเซลทั้งหมดในรูปภาพจากกล้อง ในทางตรงกันข้าม Depth API ที่สมบูรณ์จะให้ความลึกโดยประมาณสำหรับทุกพิกเซล แต่ข้อมูลความลึกต่อพิกเซลอาจมีความถูกต้องน้อยลงเนื่องจากการปรับค่าประมาณความลึกให้ราบรื่นและการประมาณค่าความลึก รูปแบบและขนาดของรูปภาพที่มีความลึกเหมือนกันใน API ทั้งคู่ ต่างกันที่เนื้อหาเท่านั้น
ตารางต่อไปนี้แสดงความแตกต่างระหว่าง Raw Depth API กับ Depth API เต็มรูปแบบโดยใช้รูปภาพเก้าอี้และโต๊ะในห้องครัว
API | การคืนสินค้า | รูปภาพจากกล้อง | รูปภาพความลึก | รูปภาพความเชื่อมั่น |
---|---|---|---|---|
API ความลึกของข้อมูลดิบ |
|
|||
API ความลึกแบบเต็ม |
|
ไม่มีข้อมูล |
รูปภาพความเชื่อมั่น
ในภาพความเชื่อมั่นที่แสดงโดย Raw Depth API พิกเซลที่อ่อนกว่าจะมีค่าความเชื่อมั่นสูงกว่า ขณะที่พิกเซลสีขาวแสดงถึงความเชื่อมั่นเต็ม และพิกเซลสีดำแสดงถึงไม่มีความเชื่อมั่น โดยทั่วไป พื้นที่ในภาพจากกล้องที่มีพื้นผิวมากกว่า เช่น ต้นไม้ จะมีความเชื่อมั่นด้านความลึกขั้นต้นสูงกว่าภูมิภาคที่ไม่มีพื้นผิว เช่น ผนังว่างเปล่า พื้นผิวที่ไม่มีพื้นผิวมักจะให้ค่าความเชื่อมั่นเป็น 0
หากอุปกรณ์เป้าหมายมีเซ็นเซอร์วัดความลึกของฮาร์ดแวร์ที่รองรับ ความเชื่อมั่นในพื้นที่ของรูปภาพที่อยู่ใกล้กล้องมากพอจะสูงขึ้นแม้บนพื้นผิวที่ไม่มีพื้นผิว
ต้นทุนการประมวลผล
ต้นทุนการประมวลผลของ Raw Depth API อยู่ที่ประมาณครึ่งหนึ่งของต้นทุนการประมวลผลสำหรับ Depth API เต็มรูปแบบ
Use Case
เมื่อใช้ Raw Depth API คุณจะได้รับภาพที่มีความลึกซึ่งแสดงรูปทรงเรขาคณิตของวัตถุในฉากได้ละเอียดยิ่งขึ้น ข้อมูลความลึกแบบข้อมูลดิบมีประโยชน์เมื่อสร้างประสบการณ์ AR ที่จำเป็นต้องใช้ความแม่นยำและรายละเอียดที่เพิ่มขึ้นสำหรับงานทำความเข้าใจเรขาคณิต ตัวอย่างการใช้งานมีดังนี้
- การสร้างใหม่แบบ 3 มิติ
- การวัด
- การตรวจจับรูปร่าง
ข้อกำหนดเบื้องต้น
ตรวจสอบว่าคุณเข้าใจแนวคิด AR พื้นฐาน และวิธีกำหนดค่าเซสชัน ARCore ก่อนดำเนินการต่อ
เปิดใช้ความลึก
ในเซสชัน ARCore ใหม่ ให้ตรวจสอบว่าอุปกรณ์ของผู้ใช้รองรับ Depth หรือไม่ อุปกรณ์ที่เข้ากันได้กับ ARCore บางรุ่นอาจไม่รองรับ Depth API เนื่องจากข้อจำกัดด้านพลังงานในการประมวลผล ความลึกจะปิดอยู่โดยค่าเริ่มต้นใน ARCore เพื่อประหยัดทรัพยากร เปิดใช้โหมดความลึกเพื่อให้แอปใช้ Depth API
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 }) }
รับรูปภาพความลึกและความเชื่อมั่นล่าสุด
เรียกใช้ frame.acquireRawDepthImage16Bits()
เพื่อรับรูปภาพความลึกแบบข้อมูลดิบล่าสุด พิกเซลรูปภาพบางส่วนที่แสดงผลผ่าน Raw Depth API จะไม่มีข้อมูลความลึก และเฟรม ARCore บางเฟรมจะไม่มีรูปภาพความลึกแบบข้อมูลดิบใหม่ หากต้องการดูว่ารูปภาพความลึกแบบดิบของเฟรมปัจจุบันเป็นรูปภาพใหม่หรือไม่ ให้เปรียบเทียบการประทับเวลากับการประทับเวลาของรูปภาพความลึกแบบ RAW ก่อนหน้า หากการประทับเวลาแตกต่างกัน รูปภาพความลึกแบบข้อมูลดิบจะอิงตามข้อมูลความลึกใหม่ มิเช่นนั้น ภาพความชัดลึกจะแสดงภาพความลึกก่อนหน้าอีกครั้ง
เรียกใช้ frame.acquireRawDepthConfidenceImage()
เพื่อรับรูปภาพความเชื่อมั่น คุณสามารถใช้รูปภาพความเชื่อมั่นเพื่อตรวจสอบความแม่นยำของพิกเซลความลึกดิบแต่ละพิกเซล รูปภาพความเชื่อมั่นจะแสดงในรูปแบบ Y8 แต่ละพิกเซลจะเป็นจำนวนเต็มที่ไม่มีเครื่องหมาย 8 บิต 0
หมายถึงมีความเชื่อมั่นน้อยที่สุด ส่วน 255
หมายถึงมีความเชื่อมั่นมากที่สุด
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. }
สิ่งที่จะเกิดขึ้นหลังจากนี้
- ดูวิธีสร้างแอปของคุณเองด้วย Raw Depth โดยไปที่ Raw Depth Codelab