इमेज ऐनलिसिस

इमेज का विश्लेषण करने के लिए, आपके ऐप्लिकेशन को सीपीयू से ऐक्सेस की जा सकने वाली इमेज मिलती है. इस पर इमेज प्रोसेसिंग, कंप्यूटर विज़न या मशीन लर्निंग का अनुमान लगाया जा सकता है. ऐप्लिकेशन, analyze() तरीके को लागू करता है. यह तरीका हर फ़्रेम पर चलता है.

अपने CameraX ऐप्लिकेशन के साथ Google की ML Kit को इंटिग्रेट करने का तरीका जानने के लिए, ML Kit Analyzer देखें.

ऑपरेटिंग मोड

जब ऐप्लिकेशन की विश्लेषण पाइपलाइन, CameraX के फ़्रेम रेट की ज़रूरी शर्तों को पूरा नहीं कर पाती, तो CameraX को इनमें से किसी एक तरीके से फ़्रेम छोड़ने के लिए कॉन्फ़िगर किया जा सकता है:

• नॉन-ब्लॉकिंग (डिफ़ॉल्ट): इस मोड में, एक्ज़ीक्यूटर हमेशा इमेज बफ़र में सबसे नई इमेज को कैश मेमोरी में सेव करता है. यह एक की गहराई वाली सूची की तरह होता है. इस दौरान, ऐप्लिकेशन पिछली इमेज का विश्लेषण करता है. अगर ऐप्लिकेशन की प्रोसेसिंग पूरी होने से पहले CameraX को कोई नई इमेज मिलती है, तो नई इमेज को उसी बफ़र में सेव किया जाता है. इससे पिछली इमेज ओवरराइट हो जाती है. ध्यान दें कि इस स्थिति में ImageAnalysis.Builder.setImageQueueDepth() का कोई असर नहीं होता है. साथ ही, बफ़र कॉन्टेंट को हमेशा ओवरराइट किया जाता है. इस नॉन-ब्लॉकिंग मोड को चालू करने के लिए, STRATEGY_KEEP_ONLY_LATEST के साथ setBackpressureStrategy() को कॉल करें. एग्ज़ेक्यूटर के असर के बारे में ज़्यादा जानने के लिए, STRATEGY_KEEP_ONLY_LATEST के लिए रेफ़रंस दस्तावेज़ देखें.

• ब्लॉकिंग: इस मोड में, इंटरनल एक्ज़ीक्यूटर, इंटरनल इमेज की सूची में कई इमेज जोड़ सकता है. साथ ही, सूची भरने के बाद ही फ़्रेम को ड्रॉप करना शुरू करता है. ब्लॉक करने की प्रोसेस, कैमरे के पूरे डिवाइस स्कोप में होती है: अगर कैमरे के डिवाइस में एक से ज़्यादा इस्तेमाल के मामले हैं, तो CameraX इन इमेज को प्रोसेस करते समय, उन सभी इस्तेमाल के मामलों को ब्लॉक कर देगा. उदाहरण के लिए, जब झलक और इमेज का विश्लेषण, दोनों को किसी कैमरा डिवाइस से बाउंड किया जाता है, तो CameraX के इमेज प्रोसेस करने के दौरान झलक भी ब्लॉक हो जाएगी. ब्लॉकिंग मोड को चालू करने के लिए, STRATEGY_BLOCK_PRODUCER को setBackpressureStrategy() पर पास करें. ImageAnalysis.Builder.setImageQueueDepth() का इस्तेमाल करके, इमेज की सूची की डेप्थ को भी कॉन्फ़िगर किया जा सकता है.

कम इंतज़ार के समय और बेहतर परफ़ॉर्मेंस वाले ऐनलाइज़र की मदद से, किसी इमेज का विश्लेषण करने में लगने वाला कुल समय, CameraX फ़्रेम की अवधि से कम होता है. उदाहरण के लिए, 60fps के लिए 16 मि॰से॰. दोनों में से किसी भी ऑपरेटिंग मोड का इस्तेमाल करने पर, आपको बेहतर अनुभव मिलता है. ब्लॉकिंग मोड अब भी कुछ मामलों में मददगार हो सकता है. जैसे, सिस्टम में कुछ समय के लिए होने वाली गड़बड़ियों को ठीक करने में.

ज़्यादा इंतज़ार के समय और बेहतर परफ़ॉर्मेंस वाले ऐनलाइज़र के साथ, इंतज़ार के समय को कम करने के लिए, लंबी सूची वाले ब्लॉकिंग मोड की ज़रूरत होती है. हालांकि, ध्यान दें कि ऐप्लिकेशन अब भी सभी फ़्रेम प्रोसेस कर सकता है.

अगर ऐनलाइज़र को ज़्यादा समय लगता है और लेटेंसी ज़्यादा है (ऐनलाइज़र सभी फ़्रेम प्रोसेस नहीं कर पाता), तो नॉन-ब्लॉकिंग मोड ज़्यादा सही विकल्प हो सकता है. ऐसा इसलिए, क्योंकि विश्लेषण के लिए फ़्रेम को छोड़ना पड़ता है. हालांकि, एक साथ होने वाले अन्य इस्तेमाल के उदाहरणों में अब भी सभी फ़्रेम देखे जा सकते हैं.

लागू करना

अपने ऐप्लिकेशन में इमेज का विश्लेषण करने की सुविधा इस्तेमाल करने के लिए, यह तरीका अपनाएं:

• ImageAnalysis के इस्तेमाल का उदाहरण बनाएं.
• ImageAnalysis.Analyzer बनाएं.
• अपने ऐनलाइज़र को ImageAnalysis पर सेट करें.
• लाइफ़साइकल के मालिक, कैमरा सिलेक्टर, और ImageAnalysis इस्तेमाल के उदाहरण को लाइफ़साइकल से जोड़ें.

बाइंड करने के तुरंत बाद, CameraX आपके रजिस्टर किए गए ऐनलाइज़र को इमेज भेजता है. विश्लेषण पूरा होने के बाद, ImageAnalysis.clearAnalyzer() को कॉल करें या विश्लेषण रोकने के लिए, ImageAnalysis इस्तेमाल के उदाहरण को अनबाइंड करें.

ImageAnalysis के इस्तेमाल का उदाहरण बनाना

ImageAnalysis, आपके ऐनलाइज़र (इमेज का इस्तेमाल करने वाला) को CameraX से कनेक्ट करता है. CameraX, इमेज जनरेट करने वाला टूल है. ऐप्लिकेशन, ImageAnalysis ऑब्जेक्ट बनाने के लिए, ImageAnalysis.Builder का इस्तेमाल कर सकते हैं. ImageAnalysis.Builder की मदद से, ऐप्लिकेशन में ये चीज़ें कॉन्फ़िगर की जा सकती हैं:

• इमेज आउटपुट के पैरामीटर:
  • फ़ॉर्मैट: CameraX, setOutputImageFormat(int) की मदद से YUV_420_888 और RGBA_8888 के साथ काम करता है. डिफ़ॉल्ट फ़ॉर्मैट YUV_420_888 है.
  • रिज़ॉल्यूशन और आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात): इनमें से किसी भी पैरामीटर को सेट किया जा सकता है. हालांकि, ध्यान दें कि दोनों वैल्यू को एक साथ सेट नहीं किया जा सकता.
  • रोटेशन.
  • टारगेट का नाम: इस पैरामीटर का इस्तेमाल, डीबग करने के लिए करें.
• इमेज फ़्लो कंट्रोल:
  • बैकग्राउंड एक्ज़ीक्यूटर
  • इमेज की सूची (ऐनलाइज़र और CameraX के बीच) की डेप्थ
  • बैक प्रेशर स्ट्रेटजी

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

कोई ऐप्लिकेशन, आउटपुट इमेज के पिक्सल को YUV (डिफ़ॉल्ट) या RGBA कलर स्पेस में कॉन्फ़िगर कर सकता है. आरजीबीए आउटपुट फ़ॉर्मैट सेट करते समय, CameraX इमेज को YUV से आरजीबीए कलर स्पेस में बदलता है. साथ ही, इमेज बिट को ImageProxy के पहले प्लेन के ByteBuffer में पैक करता है. अन्य दो प्लेन का इस्तेमाल नहीं किया जाता. इसके लिए, यह क्रम अपनाया जाता है:

ImageProxy.getPlanes()[0].buffer[0]: alpha
ImageProxy.getPlanes()[0].buffer[1]: red
ImageProxy.getPlanes()[0].buffer[2]: green
ImageProxy.getPlanes()[0].buffer[3]: blue
...

इमेज का मुश्किल विश्लेषण करते समय, हो सकता है कि डिवाइस फ़्रेम रेट को बनाए न रख पाए. ऐसे में, CameraX को फ़्रेम ड्रॉप करने के लिए कॉन्फ़िगर किया जा सकता है. इसके लिए, इस विषय के ऑपरेटिंग मोड सेक्शन में बताई गई रणनीतियों का इस्तेमाल करें.

अपना ऐनलाइज़र बनाना

ऐप्लिकेशन, ImageAnalysis.Analyzer इंटरफ़ेस को लागू करके और analyze(ImageProxy image) को ओवरराइड करके, ऐनलाइज़र बना सकते हैं. हर ऐनलाइज़र में, ऐप्लिकेशन को एक ImageProxy मिलता है. यह Media.Image के लिए एक रैपर होता है. इमेज फ़ॉर्मैट के बारे में क्वेरी करने के लिए, ImageProxy.getFormat() का इस्तेमाल किया जा सकता है. फ़ॉर्मैट, इनमें से कोई एक वैल्यू होती है जिसे ऐप्लिकेशन, ImageAnalysis.Builder के साथ उपलब्ध कराता है:

• ImageFormat.RGBA_8888 अगर ऐप्लिकेशन ने OUTPUT_IMAGE_FORMAT_RGBA_8888 का अनुरोध किया है.
• ImageFormat.YUV_420_888 अगर ऐप्लिकेशन ने OUTPUT_IMAGE_FORMAT_YUV_420_888 का अनुरोध किया है.

कलर स्पेस कॉन्फ़िगरेशन और पिक्सल बाइट को कहां से वापस पाया जा सकता है, यह जानने के लिए Build ImageAnalysis use case देखें.

ऐप्लिकेशन को ऐनलाइज़र में ये काम करने चाहिए:

1. किसी फ़्रेम का विश्लेषण जल्द से जल्द करें. इसके लिए, फ़्रेम रेट की तय समयसीमा का पालन करें. उदाहरण के लिए, 30 FPS के लिए 32 मि॰से॰ से कम. अगर ऐप्लिकेशन किसी फ़्रेम का विश्लेषण तेज़ी से नहीं कर पाता है, तो फ़्रेम ड्रॉप करने के लिए इस्तेमाल किए जा सकने वाले तरीकों में से किसी एक का इस्तेमाल करें.
2. ImageProxy.close() को कॉल करके, ImageProxy को CameraX पर रिलीज़ करें. ध्यान दें कि आपको रैप किए गए Media.Image के close फ़ंक्शन (Media.Image.close()) को कॉल नहीं करना चाहिए.

ऐप्लिकेशन, ImageProxy में रैप किए गए Media.Image का सीधे तौर पर इस्तेमाल कर सकते हैं. रैप की गई इमेज पर Media.Image.close() को कॉल न करें, क्योंकि इससे CameraX में इमेज शेयर करने का तरीका काम नहीं करेगा. इसके बजाय, CameraX में मौजूद Media.Image को रिलीज़ करने के लिए, ImageProxy.close() का इस्तेमाल करें.

ImageAnalysis के लिए अपना ऐनलाइज़र कॉन्फ़िगर करना

ऐनलाइज़र बनाने के बाद, विश्लेषण शुरू करने के लिए उसे रजिस्टर करें. इसके लिए, ImageAnalysis.setAnalyzer() का इस्तेमाल करें. विश्लेषण पूरा होने के बाद, रजिस्टर किए गए ऐनलाइज़र को हटाने के लिए, ImageAnalysis.clearAnalyzer() का इस्तेमाल करें.

इमेज का विश्लेषण करने के लिए, सिर्फ़ एक ऐक्टिव ऐनलाइज़र को कॉन्फ़िगर किया जा सकता है. ImageAnalysis.setAnalyzer() को कॉल करने पर, रजिस्टर किए गए ऐनलाइज़र को बदल दिया जाता है. ऐसा तब होता है, जब वह पहले से मौजूद हो. ऐप्लिकेशन, इस्तेमाल के उदाहरण को बाइंड करने से पहले या बाद में, किसी भी समय नया ऐनलाइज़र सेट कर सकते हैं.

ImageAnalysis को लाइफ़साइकल से बाइंड करना

ध्यान दें: यह चरण, CameraX के इस्तेमाल के सभी उदाहरणों के लिए ज़रूरी है. बाइंडिंग और लाइफ़साइकल को पसंद के मुताबिक बनाने के बारे में ज़्यादा जानने के लिए, CameraX API मॉडल देखें.

हमारा सुझाव है कि आप ProcessCameraProvider.bindToLifecycle() फ़ंक्शन का इस्तेमाल करके, अपने ImageAnalysis को किसी मौजूदा AndroidX लाइफ़साइकल से बाइंड करें. ध्यान दें कि bindToLifecycle() फ़ंक्शन, चुने गए Camera डिवाइस को दिखाता है. इसका इस्तेमाल, एक्सपोज़र और अन्य ऐडवांस सेटिंग को बेहतर बनाने के लिए किया जा सकता है. कैमरे के आउटपुट को कंट्रोल करने के बारे में ज़्यादा जानने के लिए, यह गाइड देखें.

यहां दिए गए उदाहरण में, पिछले चरणों की सभी चीज़ों को एक साथ जोड़ा गया है. इसमें CameraX ImageAnalysis और Preview के इस्तेमाल के उदाहरणों को lifeCycle के मालिक से जोड़ा गया है:

val imageAnalysis = ImageAnalysis.Builder()
    // enable the following line if RGBA output is needed.
    // .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
    .setTargetResolution(Size(1280, 720))
    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
    .build()
imageAnalysis.setAnalyzer(executor, ImageAnalysis.Analyzer { imageProxy ->
    val rotationDegrees = imageProxy.imageInfo.rotationDegrees
    // insert your code here.
    ...
    // after done, release the ImageProxy object
    imageProxy.close()
})

cameraProvider.bindToLifecycle(this as LifecycleOwner, cameraSelector, imageAnalysis, preview)

अन्य संसाधन

CameraX के बारे में ज़्यादा जानने के लिए, यहां दिए गए अन्य संसाधन देखें.

कोडलैब (कोड बनाना सीखना)

CameraX का इस्तेमाल शुरू करना

कोड सैंपल

CameraX के सैंपल ऐप्लिकेशन