Opencv का उपयोग करके छवि विभाजन

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

• विभाजन और आकृति
• पदानुक्रम और पुनर्प्राप्ति मोड
• लगभग अनुमान लगाने और उनके उत्तल पतवार खोजने के लिए
• कोनक्स हल
• मैचिंग कंटूर
• आकृतियों की पहचान करना (वृत्त, आयत, त्रिकोण, वर्ग, तारा)
• रेखा का पता लगाना
• बूँद का पता लगाना
• बूँदें छानना - हलकों और दीर्घवृत्त गिनना

1. विभाजन और आकृति

छवि विभाजन एक ऐसी प्रक्रिया है जिसके द्वारा हम छवियों को विभिन्न क्षेत्रों में विभाजित करते हैं। जबकि कंट्रोल्स निरंतर लाइनें या वक्र हैं जो किसी छवि में किसी वस्तु की पूर्ण सीमा को बांधते हैं या कवर करते हैं। और, यहाँ हम इमेज सेगमेंटेशन तकनीक का प्रयोग करेंगे, जिसे इमेज के भाग निकालने के लिए आकृति कहा जाता है ।

इसके अलावा कंट्रोल्स बहुत महत्वपूर्ण हैं

• वस्तु का पता लगाना
• आकृति विश्लेषण

और उनके पास वास्तविक दुनिया छवि विश्लेषण से लेकर चिकित्सा छवि विश्लेषण जैसे एमआरआई में आवेदन का बहुत व्यापक क्षेत्र है

आइए जानते हैं कि opencv में कंट्रोल्स को कैसे लागू किया जाता है, वर्गों के कंट्रोस को हटाकर।

आयात cv2 आयात np के रूप में सुन्न

चलो 3 काले वर्गों के साथ एक सरल छवि लोड करते हैं

छवि = cv2.imread ('squares.jpg') cv2.imshow ('इनपुट छवि', छवि) cv2.waitKey (0)

स्केल

ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY)

कैनी किनारों का पता लगाएं

edged = cv2.Canny (ग्रे, 30,200) cv2.imshow ('कैनी एज', किनारा) cv2.waitKey (0)

आकृति खोजना

# आपकी छवि की एक प्रति, जैसे - edged.copy (), क्योंकि कॉन्ट्रोवर्सी खोजने के लिए इमेज को बदलकर #we को _ जोड़ना पड़ता है, OpenCV वर्जन के अपग्रेड के कारण खाली तर्क के रूप में कंट्रो से पहले _, कॉन्ट्रोवर्स, hierarchive = cv2.findContours (edv, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('कंटूरिंग के बाद कैनी एज', किनारा) cv2.waitKey (0)

समोच्च फ़ाइल को यह जानने के लिए प्रिंट करना कि समोच्च क्या शामिल हैं

प्रिंट (आकृति) प्रिंट ('संख्याओं की संख्या मिली =' + str (लेन (आकृति)))

सभी कंट्रोवर्सी ड्रा करें

#use -1 सभी कंट्रोवर्स cv2.drawContours (इमेज, कंट्रोस, -1, (0,255,0), 3) cv2.imshow ('कंट्रोस', इमेज) cv2.waitKey (0) cv2 को ड्रा करने के लिए 3rd पैरामीटर के रूप में । विध्वंस करें ()

कंसोल आउटपुट -],],], …,],],]], dtype = int32), सरणी (),],

], …,

],],]], dtype = int32), सरणी (),],], …,],],]], dtype = int32)]

पाया संख्याओं की संख्या = 3। इसलिए हमें कुल तीन कंट्रोल्स मिले हैं।

अब, उपरोक्त कोड में हमने समोच्च फ़ाइल का उपयोग करके प्रिंट किया था , यह फ़ाइल बताती है कि ये कॉन्ट्रोस कैसा दिखता है, जैसा कि ऊपर कंसोल आउटपुट में मुद्रित किया गया है।

उपरोक्त कंसोल आउटपुट में हमारे पास एक मैट्रिक्स है जो x, y बिंदुओं के निर्देशांक जैसा दिखता है। OpenCV स्टोर सूचियों की सूची में समरूपता रखता है। हम उपरोक्त कंसोल आउटपुट को निम्न प्रकार से दिखा सकते हैं:

संपर्क 1 संपर्क 2 संपर्क 3

], सरणी (), सरणी (), ,],],],],],]

…,…,…, ,],],],],],]

]], dtype = int32),]], dtype = int32),]], dtype = int32)]

अब, जैसा कि हम समोच्च फ़ाइल पर लंबाई फ़ंक्शन का उपयोग करते हैं, हमें लंबाई 3 के बराबर मिलती है, इसका मतलब है कि उस फ़ाइल में तीन सूचियों की सूची थी, अर्थात तीन आकृति।

अब, कल्पना 1 उस सरणी में पहला तत्व है और उस सूची में सभी निर्देशांक की सूची शामिल है और ये निर्देशांक उन बिंदुओं के साथ बिंदु हैं जिन्हें हमने अभी देखा था, हरे आयताकार बक्से के रूप में।

इन निर्देशांक को संग्रहीत करने के लिए अलग-अलग विधियाँ हैं और इन्हें सन्निकटन विधियाँ कहा जाता है, मूलतः सन्निकटन विधियाँ दो प्रकार की होती हैं

• cv2.CHAIN_APPROX_NONE
• cv2.CHAIN_APPROX_SIMPLE

cv2.CHAIN_APPROX_NONE सभी सीमा बिंदु संग्रहीत करता है, लेकिन हमें सभी सीमा बिंदुओं की आवश्यकता नहीं है, यदि बिंदु एक सीधी रेखा बनाता है, तो हमें केवल उस बिंदु पर प्रारंभ बिंदु और समाप्ति बिंदु की आवश्यकता होती है।

cv2.CHAIN_APPROX_SIMPLE इसके बजाए केवल बाउंडिंग आकृति के प्रारंभ और अंतिम बिंदु प्रदान करता है, परिणाम समोच्च जानकारी का अधिक कुशल संग्रहण है।

_, आकृति, पदानुक्रम = cv2.findContours (धार, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

उपरोक्त कोड में cv2.RETR_EXTERNAL पुनर्प्राप्ति मोड है जबकि cv2.CHAIN_APPROX_NONE है

सन्निकटन विधि।

तो हमने कंट्रोस और अंदाजे बयां विधि के बारे में जान लिया है, अब आइए पदानुक्रम और पुनर्प्राप्ति मोड का पता लगाएं।

2. पदानुक्रम और पुनर्प्राप्ति मोड

पुनर्प्राप्ति मोड उप-आकृति, या बाहरी समोच्च या सभी आकृति जैसे समरूपता में पदानुक्रम को परिभाषित करता है।

अब पदानुक्रम प्रकारों पर क्रमबद्ध चार पुनर्प्राप्ति मोड हैं।

cv2.RETR_LIST - सभी आकृति को पुनः प्राप्त करता है।

cv2.RETR_EXTERNAL - केवल बाहरी या बाहरी आकृति को पुनः प्राप्त करता है।

cv2.RETR_CCOMP - सभी को 2-स्तरीय पदानुक्रम में पुनर्प्राप्त करता है।

cv2.RETR_TREE - सभी को पूर्ण पदानुक्रम में पुनर्प्राप्त करता है।

पदानुक्रम को निम्न प्रारूप में संग्रहीत किया जाता है

अब पहले दो पुनर्प्राप्ति मोड, cv2.RETR_LIST और cv2.RETR_EXTERNAL के बीच के अंतर को स्पष्ट करते हैं।

आयात cv2 आयात np के रूप में सुन्न

3 काले वर्गों के साथ एक सरल छवि को लोड करने देता है

छवि = cv2.imread ('स्क्वायर डोनट.जेपीजी') cv2.imshow ('इनपुट इमेज', इमेज) cv2.waitKey (0)

स्केल

ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY)

कैनी किनारों का पता लगाएं

edged = cv2.Canny (ग्रे, 30,200) cv2.imshow ('कैनी एज', किनारा) cv2.waitKey (0)

कॉन्ट्रोवर्सी का पता लगाना

आपकी छवि की #use कॉपी, जैसे - edged.copy (), क्योंकि कॉन्ट्रोवर्सी खोजने के लिए इमेज में परिवर्तन करना है # हमें _ जोड़ना है, ओपन कॉव वर्जन के अपग्रेड होने के कारण रिक्त तर्क के रूप में कंट्रो से पहले _, कॉन्ट्रास्ट , hierarchive = cv2.findContours (edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE) cv2.imshow ('contouring के बाद केनी किनारे', धार) cv2.waitKey (0)

समोच्च फ़ाइल को यह जानने के लिए प्रिंट करना कि समोच्च क्या शामिल हैं।

प्रिंट (आकृति) प्रिंट ('संख्याओं की संख्या मिली =' + str (लेन (आकृति)))

सभी कंट्रोवर्सी ड्रा करें

#use -1 सभी कंट्रोवर्स cv2.drawContours (इमेज, कंट्रोस, -1, (0,255,0), 3) cv2.imshow ('कंट्रोस', इमेज) cv2.waitKey (0) cv2 को ड्रा करने के लिए 3rd पैरामीटर के रूप में । विध्वंस करें

आयात cv2 आयात np के रूप में सुन्न

3 काले वर्गों के साथ एक सरल छवि को लोड करने देता है

छवि = cv2.imread ('स्क्वायर डोनट.जेपीजी') cv2.imshow ('इनपुट इमेज', इमेज) cv2.waitKey (0)

स्केल

ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY)

कैनी किनारों का पता लगाएं

edged = cv2.Canny (ग्रे, 30,200) cv2.imshow ('कैनी एज', किनारा) cv2.waitKey (0)

आकृति खोजना

आपकी छवि की #use प्रति, जैसे - edged.copy (), क्योंकि कॉन्ट्रोवर्सी खोजने के लिए इमेज में परिवर्तन होता है # हमें _ को जोड़ना होगा, ओपन cv वर्जन के अपग्रेड के कारण खाली तर्क के रूप में कंट्रो से पहले _, कॉन्ट्रास्ट , hierarchive = cv2.findContours (edged, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE) cv2.imshow ('कंटूरिंग के बाद केनी किनारे', किनारा) cv2.waitKey (0)

समोच्च फ़ाइल को यह जानने के लिए प्रिंट करना कि समोच्च क्या शामिल हैं ।

प्रिंट (आकृति) प्रिंट ('संख्याओं की संख्या मिली =' + str (लेन (आकृति)))

सभी कंट्रोवर्सी ड्रा करें

#use -1 सभी कंट्रोवर्स cv2.drawContours (इमेज, कंट्रोस, -1, (0,255,0), 3) cv2.imshow ('कंट्रोस', इमेज) cv2.waitKey (0) cv2 को ड्रा करने के लिए 3rd पैरामीटर के रूप में । विध्वंस करें ()

इसलिए उपरोक्त कोड के प्रदर्शन के माध्यम से हम स्पष्ट रूप से cv2.RETR_LIST और cv2.RETR_EXTERNNAL के बीच का अंतर देख सकते हैं, cv2.RETR_EXTERNNAL में केवल बाहरी कंट्रोल्स को ध्यान में रखा जा रहा है जबकि इनर कंट्रोल्स को नजरअंदाज किया जा रहा है।

जबकि cv2.RETR_LIST में आंतरिक अंतर्विरोधों को भी ध्यान में रखा जा रहा है।

3. कॉन्ट्रैक्ट्स को अंजाम देना और उनके उत्तल पतवार का पता लगाना

अनुमानित समोच्च में, एक समोच्च आकार दूसरे समोच्च आकार के ऊपर लगाया जाता है, जो पहले समोच्च आकार के समान नहीं हो सकता है।

सन्निकटन के लिए हम ओपनसीवी के लगभग x फंक्शन का उपयोग करते हैं जिसे नीचे समझाया गया है

cv2.approxPolyDP (समोच्च, सन्निकटन सटीकता, बंद)

पैरामीटर:

• समोच्च - व्यक्तिगत समोच्च है जो हम लगभग चाहते हैं।
• अनुमान सटीकता - सन्निकटन की सटीकता का निर्धारण करने में महत्वपूर्ण पैरामीटर, छोटा मूल्य सटीक सन्निकटन देता है, बड़े मूल्य अधिक सामान्य जानकारी देते हैं। एक अच्छा अंगूठे का नियम समोच्च परिधि के 5% से कम है।
• बंद - एक बूलियन मान जो बताता है कि क्या अनुमानित समोच्च खुला या बंद हो सकता है।

आइए एक घर के एक साधारण आंकड़े को अनुमानित करने का प्रयास करें

आयात numpy एनपी के रूप में आयात CV2

छवि लोड करें और एक प्रति रखें

छवि = cv2.imread ('house.jpg') Origin_image = image.copy () cv2.imshow ('मूल छवि', orig_image) cv2.waitKey (0)

ग्रेस्केल और छवि को बायनेरिज़ करें

ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) रिट, थ्र = cv2.threshold (ग्रे, 127,255, cv2.THRESH_BINARY -INV)

कंट्रोल्स का पता लगाएं

_, कंट्रोस, पदानुक्रम = cv2.findContours (थ्रेश.कॉपी) (, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

प्रत्येक समोच्च के माध्यम से Iterate करें और उनकी सीमा आयत की गणना करें

c में c के लिए: x, y, w, h = cv2.boundingRect (c) cv2.rectangle (Orig_image, (x, y), (x + w, y + h), (0,025-255), 2) cv2.imshow ('बाउंडिंग रेले', ओरिजिन_मेज) cv2.waitKey (0)

प्रत्येक समोच्च के माध्यम से Iterate करें और लगभग समोच्च की गणना करें

सी के लिए समोच्च में:

समोच्च परिधि सटीकता के प्रतिशत के रूप में # सटीक सटीकता = 0.03 * cv2.arcLength (सी, ट्रू) लगभग = cv2.approxPolyDP (सी, सटीकता, सत्य) cv2.drawChours (छवि: 0, (0,255,0), 2) cv2.imshow ('एप्रोक्स पॉलीडीपी', इमेज) cv2.waitKey (0) cv2.destroyAllWindows ()

4. उत्तल पतवार

उत्तल पतवार मूल रूप से बाहरी किनारे हैं, जो किसी दिए गए चित्र पर रेखाएँ दर्शाते हैं।

यह सबसे छोटा बहुभुज हो सकता है जो ऑब्जेक्ट के चारों ओर खुद को फिट कर सकता है।

आयात cv2 आयात np छवि = cv2.imread ('star.jpg') ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) cv2.imshow ('मूल छवि', छवि) cv2.waitKey (0) के रूप में सुन्न आयात करें

छवि को थ्रेसहोल्ड करें

रिट, थ्र = cv2.threshold (ग्रे, 176,255,0)

आकृति खोजें

_, कंट्रोस, पदानुक्रम = cv2.findContours (थ्रेश.कॉपी) (, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)

क्षेत्र द्वारा आकृति को क्रमबद्ध करें और फिर सबसे बड़ा फ्रेम समोच्च निकालें

n = लेन (आकृति) -1 आकृति = क्रमबद्ध (आकृति, कुंजी = cv2.contourArea, रिवर्स = जाली)

आकृति के माध्यम से Iterate और उत्तल पतवार खींचना

सी के लिए समोच्च में:

hull = cv2.convexHull (c) cv2.drawContours (छवि,,, 0, (0,255,0), 2) cv2.imshow ('उत्तल हल', छवि) vv2.waitKey (0) cv2.destroyAllWindows ()

5. आकृतियों द्वारा कंटूर का मिलान

cv2.matchShapes (समोच्च टेम्पलेट, समोच्च विधि, विधि पैरामीटर)

आउटपुट - मैच वैल्यू (कम मूल्य का मतलब है एक करीबी मैच)

समोच्च टेम्पलेट - यह हमारा संदर्भ समोच्च है जिसे हम एक नई छवि में खोजने की कोशिश कर रहे हैं।

समोच्च - व्यक्तिगत समोच्च हम के खिलाफ जाँच कर रहे हैं।

विधि - समोच्च मिलान का प्रकार (1,2,3)।

विधि पैरामीटर - 0.0 के रूप में अकेला छोड़ दें (अजगर opencv में उपयोग नहीं किया गया)

आयात cv2 आयात np के रूप में सुन्न

आकृति टेम्पलेट या संदर्भ छवि लोड करें

टेम्पलेट = cv2.imread ('star.jpg', 0) cv2.imshow ('टेम्पलेट', टेम्पलेट) cv2.waitKey (0)

उन आकृतियों के साथ लक्ष्य छवि लोड करें, जिन्हें हम मिलान करने का प्रयास कर रहे हैं

लक्ष्य = cv2.imread ('शेपस्टोमैच.जेपीजी') ग्रे = cv2.cvtColor (लक्ष्य, cv2.COLOR_BGR2GRAY)

Cv2.findContours का उपयोग करने से पहले पहले दोनों छवियों को थ्रेसहोल्ड करें

रिट, थ्रेश १ = सीवी २.थ्रॉल्ड (टेम्पलेट, १२ ,,२५५,०)

टेम्पलेट में आकृति खोजें

_, कंट्रोस, hierarhy = cv2.findContours (दहलीज 1, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) #we को क्षेत्र के आधार पर छंटनी करने की आवश्यकता है ताकि हम सबसे बड़ा समोच्च निकाल सकें।

छवि की रूपरेखा

Sorted_contours = सॉर्ट किया गया (contours, key = cv2.contourArea, Rev = True) #we दूसरी सबसे बड़ी समोच्च निकालें, जो हमारा टेम्पलेट समोच्च tempelate_contour होगा = दूसरे लक्ष्य छवि _, contours, hierarchy = cv2.findContours से आकृति को अनुकूलित करें। (thresh2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) आकृति में ग के लिए: #iterate लक्ष्य छवि और उपयोग cv2.matchShape में प्रत्येक समोच्च के माध्यम से समोच्च आकार की तुलना मैच = cv2.matchShapes (tempelate_contour, ग, 1,0.0) प्रिंट ("मैच") #if मैच मान 0.15 से कम है अगर मैच <0.16: निकटतम_कंटूर = c और: निकटतम_कंटूर = cv2.drawContours (लक्ष्य,, - 1, - (0,255,0), 3: cv2.imshow ('आउटपुट'), लक्ष्य) cv2.waitKey (0) cv2.destroyAllWindows ()

कंसोल आउटपुट -

0.16818605122199104

0.19946910256158912

0.18949760627309664

0.11101058276281539

अलग-अलग गणित फ़ंक्शन के साथ तीन अलग-अलग विधि हैं, हम प्रत्येक विधि के साथ प्रयोग कर सकते हैं बस cv2.matchShapes (tempelate_contour, c, 1, 0.0) विधि मान जो 1,2 और 3 से भिन्न होता है, प्रत्येक मान के लिए आपको अलग-अलग मिलान मिलेगा कंसोल आउटपुट में मान।

6. आकृतियों की पहचान करना (वृत्त, आयत, त्रिकोण, वर्ग, तारा)

OpenCV का उपयोग छवि से स्वचालित रूप से विभिन्न प्रकार की आकृतियों का पता लगाने के लिए किया जा सकता है। नीचे दिए गए कोड का उपयोग करके हम छवि से सर्कल, आयत, त्रिकोण, वर्ग और तारों का पता लगाने में सक्षम होंगे।

आयात cv2 आयात np के रूप में सुन्न

लोड करें और फिर ग्रे स्केल छवियां

छवि = cv2.imread ('आकृतियाँ.jpg') धूसर = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) cv2.imshow ('आकृतियों की पहचान', चित्र) cv2.waitKey (0) ret, th = cv2.threshold (ग्रे), 127,255,1)

समोच्च निकालें,

समोच्च में cnt के लिए:

लगभग अनुमानित बहुभुज अनुमानित करें = cv2.approxPolyDP (cnt, 0.01 * cv2.arcLength (cnt, True), True) यदि लेन (लगभग) == 3: शेप_नाम = "त्रिभुज" cv2.drawContours (छवि), 0, (0,255)। 0), - 1)

केंद्र में पाठ रखने के लिए समोच्च केंद्र ढूंढें

M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (छवि, shape_name, (cx-50, cy), cv2.FH_HERSHEY_SIMPLEX, 1, (0,0), 0), 1) elif लेन (लगभग) == 4: एक्स, वाई, w, ज = cv2.boundingRect (cnt) एम = cv2.moments (cnt) cx = पूर्णांक (एम / एम) cy = पूर्णांक (एम /म)

यह देखने के लिए जांचें कि क्या चार तरफा बहुभुज वर्गाकार या आयताकार है

# cv2.oubingRect, पिक्सेल में बाईं चौड़ाई और ऊँचाई वापस लौटाता है, शीर्ष #left कोने से शुरू होता है , वर्ग के लिए यह लगभग समान होगा यदि अनुपस्थित (wh) <= 3: shape_name = "वर्ग" #find समोच्च केंद्र पर पाठ रखने के लिए केंद्र cv2.drawContours (छवि,, 0, (0,125,255), - 1) cv2.putText (छवि, shape_name, (cx-50, cy), cv2.FONT_HHHEY_SIMPLEX, 1, (0,0,0), 1) और: size_name = "Reactangle" #find समोच्च केंद्र को cv2.drawContours (छवि, 0, (0,0,255) पर पाठ रखने के लिए , - 1) M = cv2.moments (cnt) xx = int (M / M) cy = int (M / M) cv2.putText (छवि, shape_name, (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, ((0,0,0), 1) elif len (लगभग) == 10: shape_name = 'सितारा' cv2.drawContours (छवि,, 0, (255,255,0), - 1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (छवि, shape_name) (cx-50, cy), cv2.FONT_HERSHEY_SIMPLEX, 1, (0,0,0), 1) elif len (लगभग)> = 15: shape_name = 'सर्कल' cv2.drawContours (छवि;), 0 (0,255,255), -1) M = cv2.moments (cnt) cx = int (M / M) cy = int (M / M) cv2.putText (छवि, shape_name, (cx-50, cy), c22.FONT_HERSHEY_SIMPLEX, 1, 1 (0,0,0), 1) cv2.imshow ('आकृतियों की पहचान', चित्र) cv2.waitKey (0) cv2.destroyAllWindows ()

7. रेखा का पता लगाना

OpenCV में लाइन डिटेक्शन बहुत महत्वपूर्ण अवधारणा है, और वास्तविक दुनिया में इसका एक आशाजनक उपयोग है। स्वायत्त कारें लेन और सड़कों का पता लगाने के लिए लाइन डिटेक्शन एल्गोरिदम का उपयोग करती हैं।

लाइन डिटेक्शन में हम दो एल्गोरिदम से निपटेंगे,

• पर्याप्त लाइन एल्गोरिथम
• प्रोबलिस्टिक हूप लाइन एल्गोरिथम ।

आपको समीकरण, y = mx + c के साथ हाई स्कूल गणित से लाइन का प्रतिनिधित्व याद हो सकता है ।

हालाँकि, OpenCV लाइन में एक और तरीका है

Ρ = xcosӨ + ysincos the के ऊपर का समीकरण रेखा का OpenCV निरूपण है, जिसमें ρ मूल से रेखा की लंबवत दूरी है और to इस रेखा के सामान्य से मूल में बनने वाला कोण है (रेडियन में मापा जाता है, जिसमें 1pi रेडियंस / 180 = 1 डिग्री)।

लाइन का पता लगाने के लिए OpenCV फ़ंक्शन के रूप में दिया गया है

cv2.HoughLines (बिनाराइज्ड इमेज, ρ सटीकता, thresh सटीकता, दहलीज), जिसमें थ्रेशोल्ड न्यूनतम वोट है इसके लिए एक पंक्ति माना जाता है।

अब opencv के Hough लाइन फंक्शन की मदद से एक बॉक्स इमेज के लिए लाइनों का पता लगाते हैं।

आयात CV2 आयात numpy एनपी के रूप में छवि = cv2.imread ('box.jpg')

ग्रेस्केल और कैनी किनारों को निकाला गया

ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) किनारों = cv2.Canny (ग्रे, 100,170, एपर्चराइज = 3)

1 पिक्सेल की आरएच सटीकता का उपयोग करके लंबी लाइनें चलाएं

(np.pi / 180) की # सटीकता जो 1 डिग्री है # लाइन थ्रेशोल्ड 240 (लाइन पर बिंदुओं की संख्या) लाइनों = cv2.HoughLines (किनारों, 1, np.pi / 180, 240) # सेट पर सेट है प्रत्येक पंक्ति के माध्यम से और cv2.lines (यानी अंतिम बिंदुओं की आवश्यकता) द्वारा श्रेणी में (0, len (लाइनें)) के लिए प्रारूप में रूपांतरित करें : rho के लिए, लाइनों में थीटा: a = np.cos (थीटा) b = np.sin (थीटा) x0 = a * rho y0 = b * rho X1 = int (x0 + 1000 * (- b)) y1 = int (y0 + 1000 * (a)) x2 = int (x0-1000 * (-b)) y2 = int (y0-1000 * (a)) cv2.line (छवि, (X1, y1), (x2, y2), (0,255,0), 2) cv2.imow ('हूप लाइन्स'), छवि) cv2.waitKey (0) cv2.destroyAllWindows ()

अब चलिए ऊपर की लाइन डिटेक्शन को प्रोबेबिलिस्टिक होफ लाइन के अन्य एल्गोरिदम के साथ दोहराते हैं।

संभावित हाबिल लाइन के पीछे का विचार यह है कि लाइन डिटेक्शन के लिए पर्याप्त बिंदुओं का एक यादृच्छिक सबसेट लेना है।

प्रोबेबिलिस्टिक हूप लाइन के लिए OpenCV फ़ंक्शन को cv2.HoughLinesP (बिनाराइज्ड इमेज, ρ सटीकता,, सटीकता, दहलीज, न्यूनतम लाइन लंबाई, अधिकतम लाइन गैप) के रूप में दर्शाया गया है

अब प्रोबेबिलिस्टिक हूप लाइनों की मदद से बॉक्स लाइनों का पता लगाएं।

आयात cv2 आयात np के रूप में सुन्न

ग्रेस्केल और कैनी किनारों को निकाला गया

छवि = cv2.imread ('box.jpg') ग्रे = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) किनारों = cv2.Canny (ग्रे, 50,150, एपर्चराइज़ = 3) #again हम एक ही आरएचओ का उपयोग करते हैं और थीटा सटीकता # हाथी, हम कम से कम वोट 100 के (रेखा के साथ अंक) निर्दिष्ट 5 पिक्सल के #and मिनट लाइन की लंबाई और 10 पिक्सल की पंक्तियों के बीच की खाई को अधिकतम लाइनों = cv2.HoughLinesP (किनारों, 1, np.pi / 180,100,100,10) मैं के लिए रेंज में (0, लेन (लाइनें)): X1, y1, x2, y2 के लिए लाइनों में: cv2.line (छवि, (X1, y1), (x2, y2), (0,255,0), 3) cv2। imshow ('प्रोबलिस्टिक हूप लाइन्स, इमेज) cv2.waitKey (0) cv2.destroyAllWindows

8. बूँद का पता लगाना

ब्लब्स को कनेक्टेड पिक्सल्स के एक समूह के रूप में वर्णित किया जा सकता है जो सभी एक सामान्य संपत्ति साझा करते हैं। OpenCV बूँद डिटेक्टर का उपयोग करने की विधि इस प्रवाह चार्ट के माध्यम से वर्णित है।

मुख्य बिंदुओं को खींचने के लिए हम cv2.drawKeypoints का उपयोग करते हैं जो निम्न तर्क देता है।

cv2.drawKeypoints (इनपुट छवि, की-पॉइंट, blank_output_array, रंग, झंडे)

जहां झंडे में हो सकता है

cv2.DRAW_MATCHES_FLAGS_DEFAULT

cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS

cv2.DRAW_MATCHES_FLAGS_DRAW_OVER_OUTIMG

cv2.DRAW_MATCHES_FLAGS_NOT_DRAW_SINGLE_POINTS

और यहाँ खाली शून्य शून्य के एक मैट्रिक्स द्वारा बहुत कुछ नहीं है

अब सूरजमुखी की छवि पर बूँद का पता लगाने का प्रदर्शन करते हैं, जहाँ फूल फूल के मध्य भाग होते हैं क्योंकि वे सभी फूलों के बीच आम होते हैं।

आयात CV2 आयात numpy एनपी के रूप में छवि = cv2.imread ('Sunflowers.jpg', cv2.IMREAD_GRAYSCALE)

डिफ़ॉल्ट पैरामीटर के साथ डिटेक्टर सेट करें

डिटेक्टर = cv2.impleBlobDetector_create ()

ब्लब्स का पता लगाएं

कीपॉइंट्स = डिटेक्टर। डिटैक्ट (छवि)

पता चला बूँदें लाल घेरे के रूप में

# cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS सुनिश्चित करें कि सर्कल का # आकार ब्लॉब ब्लैंक = np.zeros ((1,1) के आकार से मेल खाता है) : ब्लब्स = cv2.drawKeypoint (छवि, कीपर्स, ब्लैंक, 0,255,255, C5, C5)।

कीप दिखाओ

cv2.imshow ('blobs', blobs) cv2.waitKey (0) cv2.destroyAllWindows ()

भले ही कोड ठीक काम करता है लेकिन फूलों के असमान आकार के कारण कुछ बूँदें याद आती हैं क्योंकि अंत में फूलों की तुलना में सामने वाले फूल बड़े होते हैं।

9. ब्लब्स को फ़िल्टर करना - काउंटिंग सर्कल्स और एलिप्स

हम उनके आकार, आकार और रंग के अनुसार बूँदें छानने के लिए मापदंडों का उपयोग कर सकते हैं। बूँद डिटेक्टर के साथ मापदंडों का उपयोग करने के लिए हम ओपनसीवी के फ़ंक्शन का उपयोग करते हैं

cv2.impleBlobDetector_Params ()

हम मुख्य रूप से नीचे सूचीबद्ध इन चार मापदंडों द्वारा बूँदें छानते देखेंगे:

क्षेत्र

params.filterByArea = True / गलत params.minArea = पिक्सेल params.maxArea = पिक्सेल

घेरा

params.filterByCircularity = सत्य / गलत params.minCircularity = 1 पूर्ण होना, 0 विपरीत

उत्तलता - बूँद का क्षेत्र / उत्तल हल का क्षेत्र

params.filterByConvexity = सत्य / गलत params.minConvexity = क्षेत्र

जड़ता

params.filterByInertia = सच / गलत params.minInertiaRatio = 0.01

अब उपर्युक्त मापदंडों द्वारा बूँदें फ़िल्टर करने का प्रयास करते हैं

आयात cv2 एनपी छवि के रूप में सुन्न आयात = cv2.imread ('blobs.jpg') cv2.imshow ('मूल छवि', छवि) cv2.waitKey (0)

डिफ़ॉल्ट मापदंडों का उपयोग करके डिटेक्टर को प्रारंभ करें

डिटेक्टर = cv2.impleBlobDetector_create ()

ब्लब्स का पता लगाएं

कीपॉइंट्स = डिटेक्टर। डिटैक्ट (छवि)

लाल घेरे के रूप में हमारी छवि पर बूँदें खींचें

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (छवि, की-पॉइंट, रिक्त, (0,0,255), cv2.DRAW_MATCHES_FLAGS_DICHW_RICH_KEYPOINTS) number_of_blobs = len (keypoint) कुल पाठ = कुल = = (len (keypoints)) cv2.putText (blobs, text, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, (100,0,255), 2)

ब्लॉब कीपॉइंट वाली छवि प्रदर्शित करें

cv2.imshow ('डिफ़ॉल्ट मापदंडों का उपयोग करके बूँदें , बूँदें) cv2.waitKey (0)

हमारे फ़िल्टरिंग पैरामीटर सेट करें

cv2.impleBlobDetector params = cv2.SimpleBlobDetector_Params () का उपयोग करके # पैरामीटर की सेटिंग करें

क्षेत्र फ़िल्टरिंग पैरामीटर सेट करें

params.filterByArea = सच params.minArea = 100

परिपत्र फ़िल्टरिंग पैरामीटर सेट करें

params.filterByCircularity = सत्य params.minCircularity = 0.9

उत्तल फ़िल्टरिंग पैरामीटर सेट करें

params.filterByConvexity = गलत params.minConvexity = 0.2

जड़ता फ़िल्टरिंग पैरामीटर सेट करें

params.filterByInertia = सच params.minInertiaRatio = 0.01

पैरामीटर के साथ डिटेक्टर बनाएं

डिटेक्टर = cv2.impleBlobDetector_create (परम)

ब्लब्स का पता लगाएं

कीपॉइंट्स = डिटेक्टर। डिटैक्ट (छवि)

छवियों पर लाल हलकों के रूप में बूँदें खींचें

blank = np.zeros ((1,1)) blobs = cv2.drawKeypoints (छवि, की-पॉइंट, रिक्त, (0,255,0), cv2.DRAW_MATCHES_FLAGS_DICHW_RICH_KEYPOINTS) number_of_blobs = len (keypoint) पाठ = कुल = =। str (len (keypoint)) cv2.putText (blobs, text, (20,550), cv2.FONT_HERSHEY_SIMPLEX, 1, 1 (0,100,255), 2)

बूँद दिखाओ

cv2.imshow ('फ़िल्टरिंग सर्कुलर ब्लब्स', ब्लब्स ) cv2.waitKey (0) cv2.destroyAllWindows ()

तो यह है कि पायथन-ओपनसीवी में छवि विभाजन कैसे किया जा सकता है। कंप्यूटर दृष्टि और OpenCV की अच्छी समझ पाने के लिए, पिछले लेखों से गुजरें (Python OpenCV और Image Manipulations in Python OpenCV के साथ आरंभ करना) और आप कंप्यूटर विज़न के साथ कुछ अच्छा कर पाएंगे।