इमेज ऐनलिसिस

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

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

ऑपरेटिंग मोड

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

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

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

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

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

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

लागू करना

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

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

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

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

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

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

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

कोई ऐप्लिकेशन आउटपुट इमेज पिक्सल को YUV (डिफ़ॉल्ट) में होने के लिए कॉन्फ़िगर कर सकता है या RGBA कलर स्पेस. RGBA आउटपुट फ़ॉर्मैट सेट करते समय, CameraX आंतरिक रूप से यह इमेज को YUV से RGBA कलर स्पेस में बदलता है और इमेज बिट को 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
...

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

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

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

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

बिल्ड ImageAnalysis के इस्तेमाल का उदाहरण देखें का इस्तेमाल करें. साथ ही, जहां पिक्सल बाइट वापस पाए जा सकते हैं.

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

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

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

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

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

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

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

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

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

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)

ImageAnalysis imageAnalysis =
    new ImageAnalysis.Builder()
        // enable the following line if RGBA output is needed.
        //.setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
        .setTargetResolution(new Size(1280, 720))
        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
        .build();

imageAnalysis.setAnalyzer(executor, new ImageAnalysis.Analyzer() {
    @Override
    public void analyze(@NonNull ImageProxy imageProxy) {
        int rotationDegrees = imageProxy.getImageInfo().getRotationDegrees();
            // insert your code here.
            ...
            // after done, release the ImageProxy object
            imageProxy.close();
        }
    });

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

अन्य संसाधन

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

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

कोड सैंपल