Opencv में छवि जोड़तोड़ (भाग)

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

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

इस ट्यूटोरियल में, हम पायथन ओपनसीवी का उपयोग करके कुछ और छवि जोड़तोड़ देखने जा रहे हैं । यहां हम Python OpenCV का उपयोग करके निम्नलिखित फ़ंक्शन को एक छवि पर लागू करना सीखेंगे:

• बिटवाइज ऑपरेशन और मास्किंग
• बातचीत और धुंधलापन
• शार्पनिंग - इमेज ब्लर्स को उल्टा करना
• थ्रेसहोल्डिंग (बिनाराइज़ेशन)
• दीक्षा, कटाव, उद्घाटन / समापन
• एज डिटेक्शन एंड इमेज ग्रेडिएंट्स
• परिप्रेक्ष्य और असर रूपांतरण
• लाइव स्केच एप्लीकेशन

1. बिटवाइज ऑपरेशन और मास्किंग

बिटवाइज़ ऑपरेशन्स आपको इमेज मास्किंग में मदद करते हैं और कुछ सरल इमेज बनाने में आपकी मदद करते हैं।

एक वर्ग बनाना

आयात cv2 आयात npy के रूप में np #we केवल दो आयामों का उपयोग करता है क्योंकि यह एक ग्रेस्केल छवि है, अगर हम एक # रंगीन छवि का उपयोग कर रहे थे, तो हमने तब एक आयत = np.zeros ((300,300,3), np.uint8) # का उपयोग किया था चौकोर वर्ग बनाना = np.zeros ((300,300), np.uint8) cv2.rectangle (वर्ग, (50,50), (250,250), 255, -1) cv2.imshow ("वर्ग", वर्ग) cv2। WaitKey (0)

एक दीर्घवृत्त बनाना

ellipse = np.zeros ((300,300), np.uint8) cv2.ellipse (ellipse, (150,150), (150,150), 30,0,180,255, -1) cv2.imshow ("ellipse"), evipse) cv2.wa2)

बिटवाइज़ ऑपरेशन के साथ प्रयोग करना

#AND_shows केवल जहाँ दो चौराहे हैं

BitwiseAND = cv2.bitwise_and (वर्ग, दीर्घवृत्त) cv2.imshow ("और", BitwiseAND) cv2.waitKey (0)

#OR_shows केवल जहाँ या तो वर्ग या दीर्घवृत्त है

BitwiseOR = cv2.bitwise_or (वर्ग, दीर्घवृत्त) cv2.imshow ("OR", BitwiseOR) cv2.waitKey (0)

#XOR_shows केवल जहाँ या तो स्वयं मौजूद हैं

BitwiseXOR = cv2.bitwise_xor (square, ellipse) cv2.imshow ("XOR", BitwiseXOR) cv2.waitKey (0)

#NOT_shows वह सब कुछ है जो दीर्घवृत्त का हिस्सा नहीं है और ऑपरेशन नहीं केवल एकल आकृति पर लागू किया जा सकता है

BitwiseNOT_elp = cv2.bitwise_not (ellipse) cv2.imshow ("NOT_ellipse", BitwiseNOT_elp) cv2.waitKey (0) cv2.destroyAllWindows ()

2. बातचीत और धुंधलापन

एक कन्वेंशन एक गणितीय कार्य है जो दो फ़ंक्शनों पर किया जाता है जो तीसरे फ़ंक्शन का उत्पादन करता है जो आमतौर पर मूल फ़ंक्शन का एक संशोधित संस्करण होता है।

आउटपुट इमेज = इमेज फंक्शन _{कर्नेल आकार}

में कंप्यूटर दृष्टि हम गिरी आकार है जिस पर हम अपने छवि पर हमारे छेड़खानी समारोह चलाने निर्दिष्ट करने के लिए है का उपयोग करें।

धुंधलापन एक ऑपरेशन है जहाँ हम पिक्सेल को एक क्षेत्र (कर्नेल) के भीतर औसत करते हैं

ओपनसीवी कर्नेल लगाकर एक छवि को धुंधला करता है, एक कर्नेल आपको बताता है कि किसी भी दिए गए पिक्सेल के मूल्य को कैसे बदला जाए, इसे अलग-अलग मात्रा में पड़ोसी पिक्सेल के साथ जोड़कर कर्नेल को अंतिम छवि का उत्पादन करने के लिए एक-एक करके छवि में प्रत्येक पिक्सेल पर लागू किया जाता है।

सीधे शब्दों में कहे तो, एक छवि संकल्पी मात्र एक तत्व गुणन दो गुणा का योग होता है और उसके बाद योग होता है।

हम इसे केवल निम्नलिखित उदाहरण से समझ सकते हैं।

ऊपर एक 3X3 कर्नेल है।

हम 1/25 से गुणा करते हैं अर्थात 1 को सामान्य करने के लिए हम तीव्रता बढ़ा रहे थे या तीव्रता को कम कर रहे थे जैसा कि छवियों को चमकाने या काला करने के मामले में।

आइए cv2.filter2D (छवि -1, कर्नेल) फ़ंक्शन द्वारा दिए गए एक opencv धुंधला विधि फ़िल्टर 2 डी का परीक्षण करें।

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

# 3x3 कर्नेल मैट्रिक्स बनाना

कर्नेल_3 x 3 = np.ones ((3,3), np.float32) / 9

# हम एक छवि के साथ कर्नेल को समझाने के लिए cv2.filter2D का उपयोग करते हैं

धुंधला = cv2.filter2D (छवि, -1, कर्नेल_3 x 3) cv2.imshow ('3x3_blurring', धुंधला) cv2.waitKey (0)

# 7x7 कर्नेल मैट्रिक्स बनाना

कर्नेल_7 x 7 = np.ones ((7,7), np.float32) / 49

# हम एक छवि के साथ कर्नेल को समझाने के लिए cv2.filter2D का उपयोग करते हैं

धुंधला = cv2.filter2D (छवि, -1, kernel_7x7) cv2.imshow ('7x7_blurring', धुंधला) cv2.waitKey (0) vv2.destroyAllWindows ()

कर रहे हैं तरीकों धुंधला के अन्य प्रकार भी:

cv2.blur - एक निर्दिष्ट विंडो पर मूल्य का लाभ उठाता है ।

cv2.GaussianBlur - समान लेकिन एक गाऊसी खिड़की का उपयोग करता है (केंद्र के चारों ओर बिंदुओं पर अधिक जोर)।

cv2.medianBlur- विंडो में सभी तत्वों के माध्यिका का उपयोग करता है।

cv2.bilateralFilter- किनारों को तेज रखते हुए ब्लार्स, यह किनारों और लाइन विवरण को संरक्षित करता है।

हम नीचे एक-एक करके देखेंगे, पहले नीचे कोड का उपयोग करके मूल छवि प्रदर्शित करें:

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

cv2.blur:

इस पद्धति में छवि को सामान्यीकृत बॉक्स फिल्टर के साथ सजाकर औसत किया जाता है, यह बॉक्स के नीचे जगह लेता है और केंद्रीय तत्व को बदलता है। यहां बॉक्स का आकार विषम और सकारात्मक होना चाहिए ।

# cv2.blur blur = cv2.blur (छवि, (3,3)) cv2.imshow ('लाभ', धब्बा) cv2.waitKey (0)

cv2. गौसियनबुलूर:

# cv2.GaussianBlur # बॉक्स फ़िल्टर के # आइए , आइए Gaussian kernel Gaussian = cv2.GaussianBlur (चित्र, (7,7), 0) cv2.imshow ('गॉसियन धुंधला', गौसियन) cv2.waitKey (0) आज़माएँ।

cv2.medianBlur:

यह कर्नेल क्षेत्र के अंतर्गत सभी पिक्सेल का माध्यिका लेता है और केंद्रीय तत्व को इस माध्य मान से बदल दिया जाता है।

# cv2.medianBlur # कर्नेल क्षेत्र और केंद्रीय तत्व #is के अंतर्गत सभी पिक्सेल के मध्यिका को इस माध्य मान से प्रतिस्थापित किया जाता है। मंझला = cv2.medianBlur (छवि, 5) cv2.imshow ('माध्यिका धुंधला', मंझला) cv2.waitKey (0)

cv2.bilateralFilter:

किनारों को तेज रखते हुए शोर को हटाने में द्विपक्षीय बहुत प्रभावी है

# cv2.bilateralFilter # किनारों पर द्विपक्षीय = cv2.bilateralFilter (छवि, 9,75,75) cv2.imshow ('द्विपक्षीय धुंधला', द्विपक्षीय) cv2.waitKey (0) cv2 रखते हुए शोर को हटाने में # द्विपक्षीय बहुत प्रभावी है । विध्वंस करें ()

इमेज डे-नॉइज़िंग-नॉन लोकल का मतलब है डेनोइजिंग

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

#parameter के बाद कोई भी फ़िल्टर शक्ति 'h' नहीं है (5-10 अच्छी रेंज है) #next रंग घटकों के लिए h है, फिर से h के समान मान सेट करें

dst = cv2.fastNlMeansDenoisingColored (छवि, कोई नहीं, 6,6,7,21) cv2.imshow ('फास्ट का अर्थ है इनकार', dst) cv2.waitKey (0) cv2.destroyAllWindows ()

गैर-स्थानीय साधनों के 4 रूपांतर हैं

cv2.fastNlMeansDenoising () - सिंगल ग्रे स्केल इमेज के लिए

cv2.fastNlMeansDenoisingColored () - एकल रंग छवि

cv2.fastNlmeansDenoisingMulti () - छवि अनुक्रम स्केल के लिए

cv2.fastNlmeansDenoisingcoloredMulti () - छवि अनुक्रम रंगीन के लिए

3. शार्पनिंग - इमेज ब्लर्स को उल्टा करना

तीक्ष्णता धुंधला के विपरीत है, यह छवि में किनारों पर ताकत या जोर देता है।

कर्नेल =,

हमारी कर्नेल मैट्रिक्स एक तक बैठ जाती है, इसलिए सामान्य करने की कोई आवश्यकता नहीं है (अर्थात मूल रूप में एक ही चमक के लिए एक कारक से गुणा करें), यदि कर्नेल को सामान्य नहीं किया जाता है, तो छवि उज्ज्वल या गहरा होगी।

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

kernel_sharpening = np.array (,

]]

# इनपुट छवि में तेज कर्नेल का उपयोग करना

sharpened = cv2.filter2D (छवि -1, kernel_sharpening) cv2.imshow ('शार्प इमेज', शार्प ) cv2.waitKey (0) cv2.estroyAllWindows ()

4. थ्रेशोडिंग (द्विभाजन)

थ्रेसहोल्डिंग एक छवि को द्विआधारी रूप में परिवर्तित करने का कार्य है। Opencv में थ्रॉल्डिंग के लिए अलग-अलग प्रकार्य है

Cv2.threshold (छवि, दहलीज मान, अधिकतम मान, सीमा प्रकार)

निम्नलिखित थ्रेशोल्ड प्रकार हैं:

• cv2.THRESH_BINARY - सबसे आम
• cv2 THRESH_BINARY_INV - सबसे आम
• cv2.THRESH_TRUNC
• cv2.THRESH_TOZERO
• cv2 THRESH_TOZERO_INV

नोट: छवि को थ्रेसहोल्ड से पहले ग्रेस्केल में बदलने की आवश्यकता है

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

127 के नीचे #value 0 (काला) पर जाता है, और 127 से ऊपर 255 (सफेद) पर जाता है

_, थ्रेस 1 = cv2.threshold (छवि, 127,255, cv2.THRESH_BINARY) cv2.imshow ('1 थ्रेशोल्ड', थ्रेश 1) cv2.waitKey (0)

127 से नीचे #value 255 तक जाता है और 127 से ऊपर मान 0 (ऊपर का उल्टा) जाता है

_, थ्रेश 2 = cv2.threshold (छवि, 127,255, cv2.THRESH_BINARY_INV) cv2.imshow ('2 थ्रेशोल्ड', थ्रू 2) cv2.waitKey (0)

127 के ऊपर #value 127 पर छोटा (आयोजित) है, 255 तर्क अप्रयुक्त है।

_, थ्रेश 3 = cv2.threshold (छवि, 127,255, cv2.THRESH_TRUNC) cv2.imshow ('3 थ्रू ट्रंक', थ्रेश 3) cv2.waitKey (0)

# 127 से नीचे के संकेत 0 पर जाते हैं, 127 से ऊपर अपरिवर्तित होते हैं

_, थ्रेश 4 = cv2.threshold (छवि, 127,255, cv2.THRESH_TOZERO) cv2.imshow ('4 थ्रेशोल्ड', थ्रूप 4) cv2.waitroey (0)

ऊपर #Revesrse, 127 से नीचे अपरिवर्तित है, 127 से ऊपर शून्य है

_, दहलीज = cv2.threshold (छवि, 127,255, cv2.THRESH_TOZERO_INV) cv2.imshow ('5 दहलीज', दहलीज) cv2.waitKey (0) cv2.destroyAllWindows ())

5. Dilation, कटाव, उद्घाटन / समापन

ये गणितीय आकृति विज्ञान के क्षेत्र में संचालन हैं

Dilation - यह एक छवि में ऑब्जेक्ट की सीमाओं में पिक्सेल जोड़ता है।

कटाव - एक छवि में वस्तु की सीमाओं पर पिक्सल को हटाता है।

खोलना - फैलाव के बाद क्षरण।

समापन - कटाव के बाद फैलाव।

खुलने से छवियों को प्रदर्शित करने में बहुत मदद मिलती है क्योंकि यह पहले कटाव (शोर को हटाता है) द्वारा छवि को निकालता है और फिर इसे पतला करता है।

फैलाव और कटाव के साथ भ्रम

विचलन और कटाव के बीच कभी-कभी भ्रम होता है आमतौर पर सफेद पृष्ठभूमि के साथ चित्रों में, जैसा कि opencv मूल पृष्ठभूमि के बजाय छवि को पतला या मिटा दिया जाता है, इसलिए इस मामले में कटाव फैलाव और इसके विपरीत के रूप में काम करता है, जैसा कि छवि के नमूने में दिखाया गया है नीचे दिखाया गया है।

याद रखें, Dilation एक छवि में वस्तुओं की सीमाओं में पिक्सेल जोड़ता है जबकि Erosion एक छवि में वस्तुओं की सीमाओं पर पिक्सेल निकालता है

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

# एरोसियन

# चलो हमारे कर्नेल आकार को परिभाषित करते हैं

कर्नेल = np.ones ((5,5), np.uint8)

# हम छवि को मिटाते हैं, यहाँ पुनरावृत्ति समय की नहीं है जब आप छवि को मिटाना चाहते हैं

कटाव = cv2.erode (छवि, कर्नेल, पुनरावृत्तियों = 1) cv2.imshow ('कटाव', अपरदन) cv2.waitKey (0)

#dilation

dilation = cv2.dilate (छवि, कर्नेल, पुनरावृत्तियाँ = 1) cv2.imshow ('फैलाव', फैलाव) cv2.waitKey (0)

#opening, शोर को दूर करने के लिए अच्छा है

ओपनिंग = cv2.morphologyEx (छवि, cv2.MORPH_OPEN, कर्नेल) cv2.imshow ('ओपनिंग', ओपनिंग) cv2.waitKey (0)

# क्लोजिंग, शोर को दूर करने के लिए अच्छा है

समापन = cv2.morphologyEx (छवि, cv2.MORPH_CLOSE, कर्नेल) cv2.imshow ('समापन', समापन) cv2.waitKey (0) cv2.dorroyAllWindows ()

6. एज डिटेक्शन एंड इमेज ग्रेडिएंट्स

कंप्यूटर विज़न में एज डिटेक्शन बहुत महत्वपूर्ण क्षेत्र है, खासकर जब कंट्रोल्स से निपटना हो।

किनारों को छवि की सीमाओं के रूप में परिभाषित किया जा सकता है, वास्तव में वे किनारों हैं जो छवियों में ऑब्जेक्ट को परिभाषित करते हैं वे छवि के बारे में बहुत सारी जानकारी संरक्षित करते हैं।

औपचारिक रूप से किनारों को एक छवि में अचानक परिवर्तन (विच्छेदन) के रूप में परिभाषित किया जा सकता है और वे पिक्सेल के रूप में अधिक जानकारी को सांकेतिक शब्दों में बदल सकते हैं।

उपरोक्त छवि से पता चलता है कि कंप्यूटर की दृष्टि कैसे छवि को पहचानती है और पहचानती है।

एज डिटेक्शन एल्गोरिदम: - एज डिटेक्शन एल्गोरिदम के तीन मुख्य प्रकार हैं

• सोबेल - ऊर्ध्वाधर या क्षैतिज छवियों पर जोर देने के लिए।
• लाप्लासियन - कम त्रुटि दर, अच्छी तरह से परिभाषित किनारों और सटीक पहचान के कारण इष्टतम।
• कैनी एज डिटेक्शन अल्गोरिद्म (1986 में john.F.Cny द्वारा रहित)

1. गाऊसी धब्बा

2. छवि की तीव्रता ढाल पाता है

3. गैर-अधिकतम दमन लागू करता है (यानी ऐसे पिक्सेल हटाता है जो किनारों नहीं हैं)।

4. हिस्टैरिसीस थ्रेशोल्ड को लागू करता है (यानी यदि पिक्सेल ऊपरी और निचले दहलीज के भीतर है, तो इसे एक किनारे माना जाता है)

आयात cv2 एनपी छवि के रूप में सुन्न आयात = cv2.imread ('input.jpg', 0) ऊंचाई, चौड़ाई = image.shape

# सोबेल

# कपड़ा उतारना किनारों

sobel_x = cv2.Sobel (छवि, cv2.CV_64F, 0,1, ksize = 5) sobel_y = cv2.Sobel (छवि, cv2.CV -64F, 1,0, ksize = 5) cv2.imshow ('मूल', चित्र) cv2.waitKey (0) cv2.imshow ('sobelx', sobel_x) cv2.waitKey (0)

# अच्छी तरह से

cv2.imshow ('sobely', sobel_y) cv2.waitKey (0)

sobel_OR = cv2.bitwise_or (sobel_x, sobel_y) cv2.imshow ('sobelOR', sobel_OR) cv2.waitKey (0)

# लैप्लियन

laplacian = cv2.aplacian (छवि, cv2.CV_64F) cv2.imshow ('लाप्लासियन', laplacian) cv2.waitKey (0)

# डेनी एज डिटेक्शन एल्गोरिथ्म थ्रेसहोल्ड के रूप में ढाल मूल्यों का उपयोग करता है # कैन को

हमें दो मूल्य प्रदान करने की आवश्यकता होती है: थ्रेशोल्ड 1 और थ्रेशोल्ड 2।

# थ्रेशोल्ड 2 की तुलना में बड़ा ढाल को एक बढ़त माना जाता है।

# 3 ग्रेडिएंट 1 से बड़ा ढाल को किनारे नहीं माना जाता है।

सीमा 1 और सीमा 2 के बीच में #values किनारे या गैर धार के रूप में या तो कर रहे हैं

#on कैसे अपने तीव्रता से जुड़े हुए हैं, इस में मामले 60 से नीचे किसी भी मूल्य रहे हैं पर विचार किया

किनारों #non wheareas ऊपर 120 किसी भी मूल्य किनारों माना जाता है।

canny = cv2.Canny (छवि, 60,120) cv2.imshow ('canny', canny ) cv2.waitKey (0) cv2.destroyAllWindows ()

14. परिप्रेक्ष्य और असर रूपांतरण

आइए एक कदम पीछे लेते हैं और एफाइन और गैर-एफाइन परिवर्तनों पर एक नज़र डालते हैं, नीचे दिखाई गई मूल छवि स्पष्ट रूप से एक नॉन एफिन इमेज है, क्योंकि किनारों को किसी बिंदु पर मिलने जा रहे हैं, लेकिन हम इसे सीधा करके और परिप्रेक्ष्य में ले सकते हैं बदल रहा है।

इस परिप्रेक्ष्य में परिवर्तन के लिए हमें मूल छवि के चार निर्देशांक और फिर आउटपुट छवि के चार बिंदुओं की आवश्यकता होती है, उन्हें अंक_ए और अंक_ द्वारा दर्शाया जाता है। सबसे पहले इन बिंदुओं की मदद से हम getPerspectiveTransform फ़ंक्शन की सहायता से एक परिवर्तन मैट्रिक्स, एम की गणना करते हैं।

और फिर इस मैट्रिक्स को अंतिम आउटपुट उत्पन्न करने के लिए warpPerspective फ़ंक्शन को दिया जाता है ।

अब आइए सबसे पहले परिप्रेक्ष्य बदलने की कोशिश करें ।

आयात cv2 आयात सुन्नत के रूप में np आयात matplotlib.pyplot plt image = cv2.imread ('paper.jpg') cv2.imshow ('मूल', छवि) cv2.witKey (0) के रूप में आयात करें

मूल छवि के 4 कोनों का # समन्वय

अंक_ए = np.float32 (,,,])

वांछित आउटपुट के 4 कोनों के

# निर्देश # ए 4 पेपर 1: 1.41 के अनुपात का उपयोग करते हैं

अंक_ = np.float32 (,,,])

# पूर्व निर्धारित परिवर्तन मैट्रिक्स, एम की गणना करने के लिए दो बिंदुओं के दो सेट करें

M = cv2.getPerspectiveTransform (points_A, points_B) warped = cv2.warpPerspective (छवि, M, (420,594)) cv2.imshow ('warrrespective', warped) cv2.waitKey (0) cv2.destroyAll विंडोज विंडो

Affine transform आसान है फिर नॉन-अफाइन ट्रांसफॉर्म क्योंकि हमें ट्रांसफॉर्मेशन पाने के लिए केवल तीन पॉइंट्स की जरूरत है। पूरी प्रक्रिया समान होती है, लेकिन परिप्रेक्ष्य परिवर्तन के बजाय अब हमारे पास परिशोधन परिवर्तन होता है और हम मैन्युअल रूप से प्रवेश करने के बजाय आकार फ़ंक्शन से वार्पएफ़ाइन में कोल्स और पंक्तियों को परिभाषित करते हैं।

आयात cv2 आयात np आयात के रूप में np आयात matplotlib.pyplot plt image = cv2.imread ('box.jpg') पंक्तियों, cols = image.shape cv2.imshow ('मूल, छवि) cv2.waitKey (0) के रूप में।

मूल छवि के 3 कोनों का # समन्वय

अंक_ए = np.float32 (,,])

वांछित उत्पादन के 3 कोनों के

# निर्देश # A4 पेपर 1: 1.41 के अनुपात का उपयोग करते हैं

अंक_ = np.float32 (,,])

# Affine #transformation मैट्रिक्स, M की गणना करने के लिए दो बिंदुओं के दो सेटों का उपयोग करें

M = cv2.getAffineTransform (points_A, points_B) warped = cv2.warpAffine (छवि, M, ( कॉल , पंक्तियाँ)) cv2.imshow ('warpine', warped) cv2.waitKey (0) cv2.destroyAllWindows ()

8. लाइव स्केच एप्लीकेशन

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

इसलिए इस कार्यक्रम की शुरुआत में हम " डीफ़ स्केच (छवि) " के तहत बयानों के एक निश्चित समूह को देख सकते हैं : "यह एक फ़ंक्शन की एक औपचारिक परिभाषा है जो एक निश्चित आउटपुट के लिए एक साथ काम करने वाले बयानों का एक समूह है।

तो यह स्केच एक फ़ंक्शन है, अजगर फ़ंक्शन में "डीफ़" द्वारा परिभाषित किया गया है और एक ":" चिह्न के साथ समाप्त होता है। इसके अलावा जिन बयानों को फ़ंक्शन के अंदर होना आवश्यक है या आप कह सकते हैं कि फ़ंक्शन को ठीक से काम करने के लिए आवश्यक हैं, फ़ंक्शन द्वारा स्वचालित रूप से साइड एलाइन किए गए हैं। इसलिए फ़ंक्शन से बाहर आने के लिए आवश्यक बयानों को पूरी तरह से संरेखित किया जाना चाहिए। आगे के संदर्भों के लिए आप Google पर बता सकते हैं कि कैसे कार्यों को अजगर में परिभाषित किया गया है।

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

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

फिर दूसरी अवधारणा opvv में ऑपरेटिंग वेबकैम की है जो cv2.VideoCapture (0) फ़ंक्शन द्वारा की जाती है , जो छवि को एक ऑब्जेक्ट कैप में संग्रहीत करता है जिसे कैप cap.read () फ़ंक्शन के साथ पढ़ा जा सकता है, इस कैप को नोट करने के लिए भी । रीड () अनंत के अंदर है जबकि लूप लगातार छवियों को कैप्चर करना था, इसे लाइव वीडियो की भावना देने के लिए, जहां वीडियो की फ्रेम दर आपके वेब कैमरा की फ्रेम दर होगी जो ज्यादातर 24 से 60 के बीच होती है एफपीएस।

cap.read () रिटर्न रिट और फ्रेम है, जहां रिट बूलियन है जो यह दर्शाता है कि फ़ंक्शन सफलतापूर्वक चलाया गया था या नहीं और फ़्रेम में वेबकैम द्वारा लिया गया चित्र है।

नीचे लाइव स्केच चलाने के लिए पूरा पायथन ओपनसीवी कोड है

आयात CV2 आयात numpy एनपी के रूप में #sketch पैदा समारोह डीईएफ़ स्केच (छवि): करने के लिए #convert छवि ग्रेस्केल img_gray = cv2.cvtColor (छवि, cv2.COLOR_BGR2GRAY) गाऊसी कलंक का उपयोग कर छवि #cleaning img_gray_blur = cv2.GaussianBlur (img_gray, (5,5), 0) #extract किनारों canny_edges = cv2.Canny (img_gray_blur, 10,70) एक उलट binarize छवि #do सेवानिवृत्त, मुखौटा = cv2.threshold (canny_edges, 70,255, cv2.THRESH_BINARY_INV) वापसी मुखौटा #initialize वेब कैमरा, टोपी वीडियो कैप्चर द्वारा प्रदान की गई वस्तु है # इसमें एक बूलियन होता है जो यह दर्शाता है कि यह सफल था (सेवानिवृत्त) #it ​​में वेबकैम (फ्रेम) कैप = cv2.VideoCapture (0) से एकत्र की गई छवियां शामिल हैं जबकि True: ret, फ्रेम = cap.read () cv2.imshow ('lifeketcher', sketch (फ्रेम)) यदि cv2.waitKey (1) == 13: # 13 एंटरकी ब्रेक #release कैमरा और क्लोज विंडो है, याद रखें कि वेब कैमरा को cap.release () cap.release () cv2.destroyAllWindows () की मदद से रिलीज करना याद रखें

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