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

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

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

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

पक्का करें कि आपको एआर के बुनियादी सिद्धांतों के बारे में पता हो साथ ही, आगे बढ़ने से पहले ARCore सेशन को कॉन्फ़िगर करने का तरीका जानें.

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

अगर आपके ऐप्लिकेशन को depth API की सुविधा की ज़रूरत है, तो एआर का अनुभव बेहतर बनाने के लिए, कई गहराई वाले सिस्टम का इस्तेमाल करता है या ऐप्लिकेशन के उन हिस्सों के लिए कोई आकर्षक फ़ॉलबैक नहीं है जो डेप्थ का इस्तेमाल करते हैं. 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 डिफ़ॉल्ट रूप से depth API को चालू नहीं करता. इसे लेने के लिए का लाभ उठाने का अवसर है, तो आपको मैन्युअल रूप से AROcclusionManager एआर कैमरे गेम ऑब्जेक्ट के साथ Camera और ARCameraBackground घटक. यहां जाएं: अपने-आप पूरी तरह से शामिल होने से रोकने की सुविधा 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 के ARFoundation के सैंपल में मिल सकता है.

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

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

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

Unity की ब्लॉग पोस्ट देखें के बारे में ज़्यादा जानकारी मिल सकती है. वर्चुअल इमेज. इसके अलावा, Unity's ARFoundation के सैंपल वर्चुअल इमेज को रोकने और डेप्थ (डेप्थ) का डेटा विज़ुअलाइज़ करने वाले टूल के बारे में बताता है.

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

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

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

टू-पास रेंडरिंग

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

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

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

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

आगे क्या होगा

  • Raw depth API की मदद से ज़्यादा सटीक सेंसिंग चालू करें.
  • ARCore depth Lab के बारे में जानें, जो डेप्थ डेटा को ऐक्सेस करने के अलग-अलग तरीकों के बारे में बताता है.