अपने एआर फ़ाउंडेशन Android ऐप्लिकेशन में गहराई का इस्तेमाल करें

डेप्थ एपीआई, डिवाइस के कैमरे को किसी सीन में मौजूद असल ऑब्जेक्ट के साइज़ और आकार को समझने में मदद करता है. यह डेप्थ इमेज या डेप्थ मैप बनाने के लिए कैमरे का इस्तेमाल करता है. इससे आपके ऐप्लिकेशन में एआर (ऑगमेंटेड रिएलिटी) की हकीकत दिखती है. डेप्थ इमेज से मिली जानकारी का इस्तेमाल करके, वर्चुअल ऑब्जेक्ट को असल दुनिया की चीज़ों के सामने या पीछे सही तरीके से दिखाया जा सकता है. इससे, इमर्सिव और असली लगने वाले उपयोगकर्ता अनुभव मिलते हैं.

गहराई की जानकारी का हिसाब गति से लगाया जाता है और इसे हार्डवेयर डेप्थ सेंसर से मिली जानकारी के साथ जोड़ा जा सकता है. अगर उपलब्ध हो, तो फ़्लाइट के समय (ToF) सेंसर जैसी जानकारी भी इसका इस्तेमाल किया जाता है. डेप्थ एपीआई पर काम करने के लिए, डिवाइस को ToF सेंसर की ज़रूरत नहीं होती.

ज़रूरी शर्तें

आगे बढ़ने से पहले, पक्का करें कि आपने बुनियादी एआर (ऑगमेंटेड रिएलिटी) सिद्धांत और ARCore सेशन को कॉन्फ़िगर करने का तरीका समझ लिया है.

अपने ऐप्लिकेशन को Depth Required या Depth Optional के लिए कॉन्फ़िगर करें (सिर्फ़ Android के लिए)

अगर आपको डेप्थ एपीआई की सुविधा की ज़रूरत होती है, क्योंकि या तो एआर (ऑगमेंटेड रिएलिटी) अनुभव का मुख्य हिस्सा, गहराई पर निर्भर होता है या ऐप्लिकेशन के उन हिस्सों के लिए कोई बेहतर फ़ॉलबैक नहीं होता, जिनके लिए डेप्थ एपीआई काम करता है, तो आपके पास Google Play Store में अपने ऐप्लिकेशन के डिस्ट्रिब्यूशन को उन डिवाइसों पर सीमित करने का विकल्प है जो डेप्थ एपीआई के साथ काम करते हैं.

अपने ऐप्लिकेशन को Depth Required बनाएं

Edit > Project Settings > XR Plug-in Management > ARCore पर नेविगेट करें.

Depth, डिफ़ॉल्ट रूप से Required पर सेट है.

अपने ऐप्लिकेशन को Depth Optional बनाएं

  1. Edit > Project Settings > XR Plug-in Management > ARCore पर नेविगेट करें.

  2. ऐप्लिकेशन को डेप्थ वैकल्पिक पर सेट करने के लिए, Depth ड्रॉप-डाउन मेन्यू से Optional चुनें.

गहराई की सुविधा चालू करें

संसाधनों को बचाने के लिए, ARCore डिफ़ॉल्ट रूप से डेप्थ एपीआई को चालू नहीं करता है. ऐप्लिकेशन के साथ काम करने वाले डिवाइसों पर डेप्थ का फ़ायदा पाने के लिए, आपको Camera और ARCameraBackground कॉम्पोनेंट के साथ, एआर कैमरा गेम ऑब्जेक्ट में AROcclusionManager कॉम्पोनेंट को मैन्युअल रूप से जोड़ना होगा. ज़्यादा जानकारी के लिए, Unity के दस्तावेज़ में अपने-आप रोकने की सुविधा देखें.

नए ARCore सेशन में, नीचे बताए गए तरीके से देखें कि किसी उपयोगकर्ता के डिवाइस में डेप्थ और डेप्थ एपीआई की सुविधा है या नहीं:

// Reference to AROcclusionManager that should be added to the AR Camera
// game object that contains the Camera and ARCameraBackground components.
var occlusionManager = …

// Check whether the user's device supports the Depth API.
if (occlusionManager.descriptor?.supportsEnvironmentDepthImage)
{
    // If depth mode is available on the user's device, perform
    // the steps you want here.
}

ज़्यादा जानकारी वाली इमेज पाएं

AROcclusionManager से, एनवायरमेंट की सबसे नई इमेज पाएं.

// Reference to AROcclusionManager that should be added to the AR Camera
// game object that contains the Camera and ARCameraBackground components.
var occlusionManager = …

if (occlusionManager.TryAcquireEnvironmentDepthCpuImage(out XRCpuImage image))
{
    using (image)
    {
        // Use the texture.
    }
}

ज़्यादा बेहतर तरीके से काम करने के लिए, सीपीयू की रॉ इमेज को RawImage में बदला जा सकता है. ऐसा करने के तरीके का उदाहरण, Unity के ARफ़ाउंडेशन सैंपल में दिया गया है.

डेप्थ वैल्यू को समझना

देखी गई वास्तविक दुनिया की ज्यामिति पर A और 2D पॉइंट a दिया गया बिंदु, जो गहराई वाली इमेज में एक ही बिंदु को दर्शाता है, a में डेप्थ API से दिया गया मान मुख्य धुरी पर CA की लंबाई के बराबर होता है. इसे कैमरा ऑरिजिन C के मुकाबले, A का z-कोऑर्डिनेट भी कहा जा सकता है. डेप्थ एपीआई के साथ काम करते समय, यह समझना ज़रूरी है कि गहराई के मान किरण CA की लंबाई के नहीं, बल्कि उसका प्रोजेक्शन है.

वर्चुअल ऑब्जेक्ट को शामिल करें और डेप्थ का डेटा देखें

Unity की ब्लॉग पोस्ट देखें. इसमें आपको डेप्थ डेटा के बारे में खास जानकारी दी गई है. साथ ही, यह भी बताया गया है कि इसका इस्तेमाल वर्चुअल इमेज को शामिल करने के लिए कैसे किया जा सकता है. इसके अलावा, Unity के ARफ़ाउंडेशन सैंपल में वर्चुअल इमेज और डेप्थ डेटा को विज़ुअलाइज़ करते हुए दिखाया गया है.

दो-पास रेंडरिंग या हर ऑब्जेक्ट, फ़ॉरवर्ड-पास रेंडरिंग का इस्तेमाल करके ओक्लूज़न को रेंडर किया जा सकता है. हर तरीका कितने काम का है, यह इस बात पर निर्भर करता है कि सीन कितना मुश्किल है और कौनसा ऐप्लिकेशन खास तौर पर इस्तेमाल किया जा रहा है.

हर ऑब्जेक्ट, फ़ॉरवर्ड-पास रेंडरिंग

हर ऑब्जेक्ट के हिसाब से, फ़ॉरवर्ड-पास रेंडरिंग से यह पता चलता है कि ऑब्जेक्ट के हर पिक्सल को उसके मटीरियल शेडर में शामिल किया गया है या नहीं. अगर पिक्सल नहीं दिखते हैं, तो आम तौर पर उन्हें ऐल्फ़ा ब्लेंडिंग की मदद से क्लिप किया जाता है. इस वजह से, उपयोगकर्ता के डिवाइस पर उन्हें दिखने लगता है.

दो-पास रेंडरिंग

दो-पास रेंडरिंग का इस्तेमाल करके, पहला पास, सभी वर्चुअल कॉन्टेंट को इंटरमीडियरी बफ़र में रेंडर करता है. दूसरा पास, असल दुनिया की गहराई और वर्चुअल सीन की गहराई के अंतर के आधार पर, वर्चुअल सीन को बैकग्राउंड के साथ ब्लेंड करता है. इस तरीके के लिए, किसी खास ऑब्जेक्ट के शेडर काम की ज़रूरत नहीं होती. साथ ही, फ़ॉरवर्ड-पास तरीके की तुलना में, यह आम तौर पर एक जैसे दिखने वाले नतीजे देता है.

गहराई वाली इमेज से दूरी निकालें

डेप्थ एपीआई का इस्तेमाल वर्चुअल ऑब्जेक्ट को शामिल करने या डेप्थ डेटा को विज़ुअलाइज़ करने के अलावा, अन्य कामों के लिए करने के लिए, डेप्थ इमेज से जानकारी निकालें.

Texture2D _depthTexture;
short[] _depthArray;

void UpdateEnvironmentDepthImage()
{
  if (_occlusionManager &&
        _occlusionManager.TryAcquireEnvironmentDepthCpuImage(out XRCpuImage image))
    {
        using (image)
        {
            UpdateRawImage(ref _depthTexture, image, TextureFormat.R16);
            _depthWidth = image.width;
            _depthHeight = image.height;
        }
    }
  var byteBuffer = _depthTexture.GetRawTextureData();
  Buffer.BlockCopy(byteBuffer, 0, _depthArray, 0, byteBuffer.Length);
}

// Obtain the depth value in meters at a normalized screen point.
public static float GetDepthFromUV(Vector2 uv, short[] depthArray)
{
    int depthX = (int)(uv.x * (DepthWidth - 1));
    int depthY = (int)(uv.y * (DepthHeight - 1));

    return GetDepthFromXY(depthX, depthY, depthArray);
}

// Obtain the depth value in meters at the specified x, y location.
public static float GetDepthFromXY(int x, int y, short[] depthArray)
{
    if (!Initialized)
    {
        return InvalidDepthValue;
    }

    if (x >= DepthWidth || x < 0 || y >= DepthHeight || y < 0)
    {
        return InvalidDepthValue;
    }

    var depthIndex = (y * DepthWidth) + x;
    var depthInShort = depthArray[depthIndex];
    var depthInMeters = depthInShort * MillimeterToMeter;
    return depthInMeters;
}

आगे क्या होगा

  • रॉ डेप्थ एपीआई की मदद से, ज़्यादा सटीक सेंसिंग की सुविधा चालू करें.
  • ARCore डेप्थ लैब देखें, जिसमें डेप्थ डेटा को ऐक्सेस करने के अलग-अलग तरीके बताए गए हैं.