<!--
CO_OP_TRANSLATOR_METADATA:
{
  "original_hash": "9c4320311c0f2c1884a6a21265d98a51",
  "translation_date": "2025-08-27T09:57:09+00:00",
  "source_file": "5-retail/lessons/2-check-stock-device/single-board-computer-count-stock.md",
  "language_code": "mr"
}
-->
# आपल्या IoT डिव्हाइसवरून स्टॉक मोजा - व्हर्च्युअल IoT हार्डवेअर आणि रास्पबेरी पाई

भविष्यवाण्या आणि त्यांच्या बाउंडिंग बॉक्सेसच्या संयोजनाचा उपयोग प्रतिमेमध्ये स्टॉक मोजण्यासाठी केला जाऊ शकतो.

## बाउंडिंग बॉक्सेस दाखवा

डिबगिंगसाठी उपयुक्त पद्धत म्हणून, तुम्ही केवळ बाउंडिंग बॉक्सेस कन्सोलवर प्रिंट करू शकत नाही, तर जेव्हा प्रतिमा कॅप्चर केली जाते तेव्हा डिस्कवर लिहिलेल्या प्रतिमेवर ते काढूही शकता.

### कार्य - बाउंडिंग बॉक्सेस प्रिंट करा

1. `stock-counter` प्रकल्प VS Code मध्ये उघडा आणि जर तुम्ही व्हर्च्युअल IoT डिव्हाइस वापरत असाल, तर व्हर्च्युअल वातावरण सक्रिय करा.

1. `for` लूपमधील `print` स्टेटमेंट खालीलप्रमाणे बदला, जेणेकरून बाउंडिंग बॉक्सेस कन्सोलवर प्रिंट होतील:

    ```python
    print(f'{prediction.tag_name}:\t{prediction.probability * 100:.2f}%\t{prediction.bounding_box}')
    ```

1. अॅप चालवा आणि कॅमेरा शेल्फवरील स्टॉककडे निर्देशित करा. बाउंडिंग बॉक्सेस कन्सोलवर प्रिंट होतील, ज्यामध्ये left, top, width आणि height चे मूल्य 0-1 दरम्यान असेल.

    ```output
    pi@raspberrypi:~/stock-counter $ python3 app.py 
    tomato paste:   33.42%  {'additional_properties': {}, 'left': 0.3455171, 'top': 0.09916268, 'width': 0.14175442, 'height': 0.29405564}
    tomato paste:   34.41%  {'additional_properties': {}, 'left': 0.48283678, 'top': 0.10242918, 'width': 0.11782813, 'height': 0.27467814}
    tomato paste:   31.25%  {'additional_properties': {}, 'left': 0.4923783, 'top': 0.35007596, 'width': 0.13668466, 'height': 0.28304994}
    tomato paste:   31.05%  {'additional_properties': {}, 'left': 0.36416405, 'top': 0.37494493, 'width': 0.14024884, 'height': 0.26880276}
    ```

### कार्य - प्रतिमेवर बाउंडिंग बॉक्सेस काढा

1. [Pillow](https://pypi.org/project/Pillow/) हे Pip पॅकेज प्रतिमांवर काढण्यासाठी वापरले जाऊ शकते. हे खालील कमांडने इन्स्टॉल करा:

    ```sh
    pip3 install pillow
    ```

    जर तुम्ही व्हर्च्युअल IoT डिव्हाइस वापरत असाल, तर हे सक्रिय व्हर्च्युअल वातावरणातून चालवा.

1. `app.py` फाईलच्या शीर्षस्थानी खालील आयात स्टेटमेंट जोडा:

    ```python
    from PIL import Image, ImageDraw, ImageColor
    ```

    हे प्रतिमा संपादित करण्यासाठी आवश्यक कोड आयात करते.

1. `app.py` फाईलच्या शेवटी खालील कोड जोडा:

    ```python
    with Image.open('image.jpg') as im:
        draw = ImageDraw.Draw(im)
    
        for prediction in predictions:
            scale_left = prediction.bounding_box.left
            scale_top = prediction.bounding_box.top
            scale_right = prediction.bounding_box.left + prediction.bounding_box.width
            scale_bottom = prediction.bounding_box.top + prediction.bounding_box.height
            
            left = scale_left * im.width
            top = scale_top * im.height
            right = scale_right * im.width
            bottom = scale_bottom * im.height
    
            draw.rectangle([left, top, right, bottom], outline=ImageColor.getrgb('red'), width=2)
    
        im.save('image.jpg')
    ```

    हा कोड संपादनासाठी आधी सेव्ह केलेली प्रतिमा उघडतो. नंतर तो भविष्यवाण्यांमधून बाउंडिंग बॉक्सेस घेतो आणि 0-1 मधील बाउंडिंग बॉक्स मूल्यांचा उपयोग करून तळाचा उजवा कोपरा काढतो. हे मूल्य प्रतिमेच्या संबंधित परिमाणाने गुणाकार करून प्रतिमा समन्वयांमध्ये रूपांतरित केले जाते. उदाहरणार्थ, जर left चे मूल्य 0.5 असेल आणि प्रतिमा 600 पिक्सेल रुंद असेल, तर ते 300 मध्ये रूपांतरित होईल (0.5 x 600 = 300).

    प्रत्येक बाउंडिंग बॉक्स लाल रेषेने प्रतिमेवर काढला जातो. शेवटी संपादित प्रतिमा सेव्ह केली जाते आणि मूळ प्रतिमेवर अधिलिखित केली जाते.

1. अॅप चालवा आणि कॅमेरा शेल्फवरील स्टॉककडे निर्देशित करा. तुम्हाला VS Code एक्सप्लोररमध्ये `image.jpg` फाईल दिसेल, आणि तुम्ही ती निवडून बाउंडिंग बॉक्सेस पाहू शकाल.

    ![4 टोमॅटो पेस्टच्या कॅन्स, प्रत्येक कॅनभोवती बाउंडिंग बॉक्सेस](../../../../../translated_images/rpi-stock-with-bounding-boxes.b5540e2ecb7cd49f1271828d3be412671d950e87625c5597ea97c90f11e01097.mr.jpg)

## स्टॉक मोजा

वरील प्रतिमेत, बाउंडिंग बॉक्सेसमध्ये थोडासा ओव्हरलॅप आहे. जर हा ओव्हरलॅप खूप मोठा असेल, तर बाउंडिंग बॉक्सेस एकाच वस्तूला सूचित करू शकतात. वस्तू योग्यरित्या मोजण्यासाठी, तुम्हाला महत्त्वपूर्ण ओव्हरलॅप असलेल्या बॉक्सेसकडे दुर्लक्ष करणे आवश्यक आहे.

### कार्य - ओव्हरलॅपकडे दुर्लक्ष करून स्टॉक मोजा

1. [Shapely](https://pypi.org/project/Shapely/) हे Pip पॅकेज इंटरसेक्शन काढण्यासाठी वापरले जाऊ शकते. जर तुम्ही रास्पबेरी पाई वापरत असाल, तर आधी एक लायब्ररी डिपेंडन्सी इन्स्टॉल करावी लागेल:

    ```sh
    sudo apt install libgeos-dev
    ```

1. Shapely Pip पॅकेज इन्स्टॉल करा:

    ```sh
    pip3 install shapely
    ```

    जर तुम्ही व्हर्च्युअल IoT डिव्हाइस वापरत असाल, तर हे सक्रिय व्हर्च्युअल वातावरणातून चालवा.

1. `app.py` फाईलच्या शीर्षस्थानी खालील आयात स्टेटमेंट जोडा:

    ```python
    from shapely.geometry import Polygon
    ```

    हे ओव्हरलॅप काढण्यासाठी बहुभुज तयार करण्यासाठी आवश्यक कोड आयात करते.

1. बाउंडिंग बॉक्सेस काढण्याच्या कोडच्या वर खालील कोड जोडा:

    ```python
    overlap_threshold = 0.20
    ```

    हे परिभाषित करते की बाउंडिंग बॉक्सेस एकाच वस्तू मानले जाण्यासाठी किती टक्के ओव्हरलॅप अनुमत आहे. 0.20 म्हणजे 20% ओव्हरलॅप.

1. Shapely वापरून ओव्हरलॅप काढण्यासाठी, बाउंडिंग बॉक्सेस Shapely बहुभुजांमध्ये रूपांतरित करणे आवश्यक आहे. हे करण्यासाठी खालील फंक्शन जोडा:

    ```python
    def create_polygon(prediction):
        scale_left = prediction.bounding_box.left
        scale_top = prediction.bounding_box.top
        scale_right = prediction.bounding_box.left + prediction.bounding_box.width
        scale_bottom = prediction.bounding_box.top + prediction.bounding_box.height
    
        return Polygon([(scale_left, scale_top), (scale_right, scale_top), (scale_right, scale_bottom), (scale_left, scale_bottom)])
    ```

    हे भविष्यवाणीच्या बाउंडिंग बॉक्सचा उपयोग करून एक बहुभुज तयार करते.

1. ओव्हरलॅपिंग वस्तू काढण्यासाठीची लॉजिक सर्व बाउंडिंग बॉक्सेसची तुलना करते. जर कोणत्याही जोडीच्या भविष्यवाण्यांमध्ये बाउंडिंग बॉक्सेस ओव्हरलॅप थ्रेशोल्डपेक्षा जास्त असेल, तर त्या भविष्यवाण्यांपैकी एक काढून टाकली जाते. सर्व भविष्यवाण्यांची तुलना करण्यासाठी, तुम्ही भविष्यवाणी 1 ची 2, 3, 4 इत्यादींसोबत तुलना करता, नंतर 2 ची 3, 4 इत्यादींसोबत. खालील कोड हे करतो:

    ```python
    to_delete = []

    for i in range(0, len(predictions)):
        polygon_1 = create_polygon(predictions[i])
    
        for j in range(i+1, len(predictions)):
            polygon_2 = create_polygon(predictions[j])
            overlap = polygon_1.intersection(polygon_2).area

            smallest_area = min(polygon_1.area, polygon_2.area)
    
            if overlap > (overlap_threshold * smallest_area):
                to_delete.append(predictions[i])
                break
    
    for d in to_delete:
        predictions.remove(d)

    print(f'Counted {len(predictions)} stock items')
    ```

    ओव्हरलॅप Shapely च्या `Polygon.intersection` पद्धतीचा वापर करून काढला जातो, जी ओव्हरलॅप असलेले बहुभुज परत करते. या बहुभुजाचा क्षेत्रफळ काढले जाते. हा ओव्हरलॅप थ्रेशोल्ड एक निश्चित मूल्य नाही, तर बाउंडिंग बॉक्सच्या टक्केवारीचा विचार करतो. त्यामुळे सर्वात लहान बाउंडिंग बॉक्स शोधला जातो आणि ओव्हरलॅप थ्रेशोल्डचा उपयोग करून ओव्हरलॅप क्षेत्रफळ काढले जाते. जर ओव्हरलॅप यापेक्षा जास्त असेल, तर भविष्यवाणी काढून टाकण्यासाठी चिन्हांकित केली जाते.

    एकदा भविष्यवाणी काढून टाकण्यासाठी चिन्हांकित केली गेली की, ती पुन्हा तपासण्याची गरज नाही, त्यामुळे अंतर्गत लूप पुढील भविष्यवाणी तपासण्यासाठी ब्रेक होतो. यादीतून आयटम काढून टाकताना त्यावर पुनरावृत्ती करता येत नाही, त्यामुळे थ्रेशोल्डपेक्षा जास्त ओव्हरलॅप असलेल्या बाउंडिंग बॉक्सेस `to_delete` यादीत जोडले जातात आणि नंतर शेवटी काढून टाकले जातात.

    शेवटी, स्टॉक काउंट कन्सोलवर प्रिंट केला जातो. हा काउंट IoT सेवेला पाठवून स्टॉक पातळी कमी असल्यास अलर्ट पाठवता येतो. हा सर्व कोड बाउंडिंग बॉक्सेस काढण्याच्या आधी आहे, त्यामुळे तुम्हाला तयार केलेल्या प्रतिमांवर ओव्हरलॅपशिवाय स्टॉक भविष्यवाणी दिसेल.

    > 💁 हा ओव्हरलॅप काढण्याचा खूप साधा मार्ग आहे, ज्यामध्ये ओव्हरलॅप असलेल्या जोडीतील पहिला काढून टाकला जातो. उत्पादन कोडसाठी, तुम्हाला येथे अधिक लॉजिक जोडावे लागेल, जसे की अनेक वस्तूंच्या ओव्हरलॅपचा विचार करणे, किंवा एक बाउंडिंग बॉक्स दुसऱ्यामध्ये समाविष्ट असल्यास.

1. अॅप चालवा आणि कॅमेरा शेल्फवरील स्टॉककडे निर्देशित करा. आउटपुटमध्ये थ्रेशोल्डपेक्षा जास्त ओव्हरलॅप नसलेल्या बाउंडिंग बॉक्सेसची संख्या दिसेल. `overlap_threshold` मूल्य समायोजित करून भविष्यवाण्या कशा दुर्लक्षित केल्या जातात ते पाहा.

> 💁 तुम्हाला हा कोड [code-count/pi](../../../../../5-retail/lessons/2-check-stock-device/code-count/pi) किंवा [code-count/virtual-iot-device](../../../../../5-retail/lessons/2-check-stock-device/code-count/virtual-iot-device) फोल्डरमध्ये सापडेल.

😀 तुमचा स्टॉक काउंटर प्रोग्राम यशस्वी झाला!

---

**अस्वीकरण**:  
हा दस्तऐवज AI भाषांतर सेवा [Co-op Translator](https://github.com/Azure/co-op-translator) वापरून भाषांतरित करण्यात आला आहे. आम्ही अचूकतेसाठी प्रयत्नशील असलो तरी कृपया लक्षात ठेवा की स्वयंचलित भाषांतरांमध्ये त्रुटी किंवा अचूकतेचा अभाव असू शकतो. मूळ भाषेतील दस्तऐवज हा अधिकृत स्रोत मानला जावा. महत्त्वाच्या माहितीसाठी व्यावसायिक मानवी भाषांतराची शिफारस केली जाते. या भाषांतराचा वापर करून निर्माण होणाऱ्या कोणत्याही गैरसमज किंवा चुकीच्या अर्थासाठी आम्ही जबाबदार राहणार नाही.