स्किटिट-इमेज लाइब्रेरी में छवि विभाजन विधियों का अवलोकन

थ्रेशोल्डिंग

यह एक निश्चित सीमा के ऊपर या नीचे पिक्सेल का चयन करके वस्तुओं को पृष्ठभूमि से अलग करने का सबसे आसान तरीका है। यह आमतौर पर तब उपयोगी होता है जब हम वस्तुओं को उनकी पृष्ठभूमि के अनुसार विभाजित करने जा रहे हैं। आप यहाँ दहलीज के बारे में अधिक पढ़ सकते हैं।

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

छवि विभाजन

छवि विश्लेषण के लिए कई पुस्तकालय लिखे गए हैं। इस लेख में, हम scikit-image, Python इमेज प्रोसेसिंग लाइब्रेरी के बारे में विस्तार से चर्चा करेंगे।

Scikit छवि

स्किकिट-इमेज इमेज प्रोसेसिंग के लिए पायथन लाइब्रेरी है।

स्थापना

scikit-image इस प्रकार स्थापित है:

pip install -U scikit-image(Linux and OSX) pip install scikit-image(Windows) # For Conda-based distributions conda install scikit-image 

अजगर छवि अवलोकन

इससे पहले कि हम छवि विभाजन के तकनीकी पहलुओं पर उतरें, स्किकिट छवि पारिस्थितिकी तंत्र के साथ थोड़ा परिचित होना महत्वपूर्ण है और यह छवियों को कैसे संसाधित करता है।

स्किमेज लाइब्रेरी से ग्रेस्केल छवि आयात करें

स्किमेज डेटा मॉड्यूल में डेटा सेट के कई अंतर्निहित उदाहरण होते हैं, जो आमतौर पर जेपीईजी या पीएनजी प्रारूप में संग्रहीत होते हैं।

 from skimage import data import numpy as np import matplotlib.pyplot as plt image = data.binary_blobs() plt.imshow(image, cmap='gray') 

स्किमेज लाइब्रेरी से रंगीन छवि आयात करें

 from skimage import data import numpy as np import matplotlib.pyplot as plt image = data.astronaut() plt.imshow(image) 

बाहरी स्रोत से एक छवि आयात करें

 # The I/O module is used for importing the image from skimage import data import numpy as np import matplotlib.pyplot as plt from skimage import io image = io.imread('skimage_logo.png') plt.imshow(image); 

कई चित्र डाउनलोड करें

 images = io.ImageCollection('../images/*.png:../images/*.jpg') print('Type:', type(images)) images.files Out[]: Type: <class 'skimage.io.collection.ImageCollection'> 

बचत छवियाँ

 #Saving file as 'logo.png' io.imsave('logo.png', logo) 

छवि विभाजन

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

इस लेख में, हम एक शिक्षक (पर्यवेक्षित) और एक शिक्षक (बिना पढ़े-लिखे) दोनों के साथ सिखाए गए मॉडलों के लिए एल्गोरिदम पर विचार करेंगे।


विभाजन के कुछ एल्गोरिदम स्किटिट-इमेज लाइब्रेरी में उपलब्ध हैं।

एक शिक्षक के साथ विभाजन: कुछ प्रारंभिक ज्ञान, संभवतः मानव इनपुट से, एल्गोरिथ्म का मार्गदर्शन करने के लिए उपयोग किया जाता है।

शिक्षक के बिना विभाजन: पूर्व ज्ञान की आवश्यकता नहीं है। ये एल्गोरिदम छवियों को महत्वपूर्ण क्षेत्रों में स्वचालित रूप से विभाजित करने का प्रयास करते हैं। वांछित परिणाम प्राप्त करने के लिए उपयोगकर्ता अभी भी कुछ मापदंडों को कॉन्फ़िगर कर सकता है।

आइए इसे एक ट्यूटोरियल छवि पर आज़माएं जो पूर्वनिर्धारित स्किट-इमेज डेटासेट के साथ आता है।

नियमित आयात

 import numpy as np import matplotlib.pyplot as plt import skimage.data as data import skimage.segmentation as seg import skimage.filters as filters import skimage.draw as draw import skimage.color as color 

साधारण इमेजिंग सुविधा

 def image_show(image, nrows=1, ncols=1, cmap='gray'): fig, ax = plt.subplots(nrows=nrows, ncols=ncols, figsize=(14, 14)) ax.imshow(image, cmap='gray') ax.axis('off') return fig, ax 

छवि

 text = data.page() image_show(text) 

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

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

 fig, ax = plt.subplots(1, 1) ax.hist(text.ravel(), bins=32, range=[0, 256]) ax.set_xlim(0, 256); 

हमारा उदाहरण 8-बिट छवि के रूप में निकला, इसलिए हमारे पास एक्स अक्ष के साथ 256 संभावित मान हैं। हिस्टोग्राम से पता चलता है कि इसमें काफी उज्ज्वल पिक्सल (0: काला, 255: सफेद) की एकाग्रता है। यह हमारे सुंदर प्रकाश पाठ पृष्ठभूमि की सबसे अधिक संभावना है, लेकिन बाकी थोड़ा धुंधला है। एक आदर्श विभाजन हिस्टोग्राम बिमोडल होगा ताकि हम बीच में एक नंबर का चयन कर सकें। अब चलो एक साधारण दहलीज मूल्य के आधार पर कुछ खंडित चित्र बनाने की कोशिश करते हैं।

नियंत्रित दहलीज

चूंकि हम खुद एक सीमा मूल्य चुनते हैं, इसलिए हम इसे नियंत्रित सीमा मूल्य कहते हैं।

 text_segmented = text > (value concluded from histogram ie 50,70,120 ) image_show(text_segmented); 

बायां: पाठ> 50 | मध्य: पाठ> 70 | सही: पाठ> 120

हमें सही परिणाम नहीं मिला, क्योंकि बाईं ओर छाया समस्या पैदा करती है। आइए अब बिना सीमा के प्रयास करें।

अनियंत्रित दहलीज

अनियंत्रित थ्रेशोल्ड स्कैटिक-छवि में कई स्वचालित थ्रेसहोल्ड निर्धारण विधियां हैं, जिन्हें इष्टतम सीमा का चयन करते समय इनपुट की आवश्यकता नहीं होती है। यहां कुछ तरीके दिए गए हैं: ओत्सू, ली, स्थानीय।

 text_threshold = filters.threshold_ # Hit tab with the cursor after the underscore to get all the methods. image_show(text < text_threshold); 

वाम ओत्सु || अधिकार: ली

स्थानीय के मामले में, हमें block_size को भी निर्दिष्ट करना होगा। ऑफसेट बेहतर परिणाम के लिए छवि को समायोजित करने में मदद करता है।

 text_threshold = filters.threshold_local(text,block_size=51, offset=10) image_show(text > text_threshold); 

यह विधि बहुत अच्छा प्रभाव देती है। काफी हद तक, कोई भी शोर क्षेत्रों से छुटकारा पा सकता है।

एक शिक्षक के साथ एक मॉडल के लिए एक एल्गोरिथ्म के साथ विभाजन

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

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

 # import the image from skimage import io image = io.imread('girl.jpg') plt.imshow(image); 

किसी भी छवि विभाजन को करने से पहले, इसे कुछ फिल्टर का उपयोग करके शोर को हटाने की सिफारिश की जाती है।

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

 image_gray = color.rgb2gray(image) image_show(image_gray); 

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

सक्रिय समोच्च विभाजन

सक्रिय पथ के विभाजन को एक सांप भी कहा जाता है और एक उपयोगकर्ता-परिभाषित पथ या ब्याज के क्षेत्र के चारों ओर लाइन का उपयोग करके आरंभ किया जाता है, और फिर इस पथ को धीरे-धीरे संकुचित और आकर्षित किया जाता है और प्रकाश और किनारों द्वारा प्रतिकृत किया जाता है।

हमारी उदाहरण छवि के लिए, आइए सांप को शुरू करने के लिए मानव सिर के चारों ओर एक चक्र बनाएं।

 def circle_points(resolution, center, radius): """ Generate points which define a circle on an image.Centre refers to the centre of the circle """ radians = np.linspace(0, 2*np.pi, resolution) c = center[1] + radius*np.cos(radians)#polar co-ordinates r = center[0] + radius*np.sin(radians) return np.array([c, r]).T # Exclude last point because a closed path should not have duplicate points points = circle_points(200, [80, 250], 80)[:-1] 

उपरोक्त गणना सर्कल की परिधि पर बिंदुओं के x और y निर्देशांक की गणना करती है। चूंकि हमने 200 का संकल्प दिया था, इसलिए यह 200 ऐसे बिंदुओं की गणना करेगा।

 fig, ax = image_show(image) ax.plot(points[:, 0], points[:, 1], '--r', lw=3) 

एल्गोरिथ्म तब व्यक्ति के चेहरे को शेष छवि से अलग करता है, चेहरे के किनारों पर एक बंद वक्र फिटिंग करता है।



हम अल्फा और बीटा नामक मापदंडों को कॉन्फ़िगर कर सकते हैं। उच्च अल्फा मान वक्र को तेजी से अनुबंधित करने का कारण बनता है, जबकि बीटा वक्र को चिकना बनाता है।

 snake = seg.active_contour(image_gray, points,alpha=0.06,beta=0.3) fig, ax = image_show(image) ax.plot(points[:, 0], points[:, 1], '--r', lw=3) ax.plot(snake[:, 0], snake[:, 1], '-b', lw=3); 

रैंडम वॉकर विभाजन

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

अगला, हम फिर से अपने उदाहरण से पिछले मानों का उपयोग करेंगे। हम अलग-अलग इनिशियलाइज़ेशन कर सकते थे, लेकिन सादगी के लिए आइए सर्किल के सिद्धांत पर टिके रहें।

 image_labels = np.zeros(image_gray.shape, dtype=np.uint8) 

रैंडम पास एल्गोरिथम इनपुट के रूप में लेबल स्वीकार करते हैं। इस प्रकार, हमारे पास व्यक्ति के पूरे चेहरे को कवर करने वाला एक बड़ा सर्कल होगा, और चेहरे के मध्य के पास एक और छोटा सर्कल होगा।

 indices = draw.circle_perimeter(80, 250,20)#from here image_labels[indices] = 1 image_labels[points[:, 1].astype(np.int), points[:, 0].astype(np.int)] = 2 image_show(image_labels); 

अब रैंडम वॉकर का उपयोग करते हैं और देखते हैं कि क्या होता है।

 image_segmented = seg.random_walker(image_gray, image_labels) # Check our results fig, ax = image_show(image_gray) ax.imshow(image_segmented == 1, alpha=0.3); 

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

 image_segmented = seg.random_walker(image_gray, image_labels, beta = 3000) # Check our results fig, ax = image_show(image_gray) ax.imshow(image_segmented == 1, alpha=0.3); 

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

एक शिक्षक के बिना विभाजन

शिक्षक के बिना विभाजन के लिए पूर्व ज्ञान की आवश्यकता नहीं है। एक ऐसी छवि पर विचार करें जो इतनी बड़ी हो कि एक बार में सभी पिक्सल को देखना असंभव हो। इस प्रकार, ऐसे मामलों में, एक शिक्षक के बिना विभाजन छवि को कई हिस्सों में विभाजित कर सकता है, इसलिए लाखों पिक्सेल के बजाय, आपके पास दसियों या सैकड़ों क्षेत्र हैं। आइए दो ऐसे एल्गोरिदम देखें:

सरल रैखिक Iterative क्लस्टरिंग

विधि (अंग्रेजी सरल रैखिक Iterative क्लस्टरिंग या SLIC) K- मीन्स नामक एक मशीन लर्निंग एल्गोरिदम का उपयोग करता है। यह छवि के सभी पिक्सेल मूल्यों को लेता है और उन्हें दिए गए उप-डोमेन में विभाजित करने की कोशिश करता है। विस्तृत जानकारी के लिए यह काम पढ़ें।

एसएलआईसी विभिन्न रंगों के साथ काम करता है, इसलिए हम मूल छवि का उपयोग करेंगे।

 image_slic = seg.slic(image,n_segments=155) 

हमें बस इतना करना चाहिए कि हम अपने द्वारा खोजे गए प्रत्येक सेगमेंट के लिए औसत मूल्य निर्धारित करें, जिससे यह एक छवि की तरह दिखता है।

 # label2rgb replaces each discrete label with the average interior color image_show(color.label2rgb(image_slic, image, kind='avg')); 

हमने इस छवि को 512 * 512 = 262,000 पिक्सेल से घटाकर 155 खंड कर दिया।

Felzenszwalb

इस विधि में मशीन लर्निंग एल्गोरिदम का भी उपयोग किया जाता है जिसे न्यूनतम फैले हुए वृक्षों का समूह कहा जाता है। फेलजेन्स्विब ने हमें क्लस्टर की सही संख्या नहीं बताई है जिसमें छवि विभाजित होगी। वह उतने ही समूहों को उत्पन्न करेगा जितना वह इसके लिए उपयुक्त देखता है।

 image_felzenszwalb = seg.felzenszwalb(image) image_show(image_felzenszwalb); 

चित्र में बहुत सारे क्षेत्र हैं। आइए अद्वितीय सेगमेंट की संख्या की गणना करें।

 np.unique(image_felzenszwalb).size 3368 

अब हम खंड पर औसत मूल्य का उपयोग करके उन्हें फिर से व्यवस्थित करते हैं, जैसा कि हमने SLIC एल्गोरिथ्म में किया था।

 image_felzenszwalb_colored = color.label2rgb(image_felzenszwalb, image, kind='avg') image_show(image_felzenszwalb_colored); 

अब हमें कम खंड मिलते हैं। यदि हम और भी कम खंड चाहते हैं, तो हम स्केल पैरामीटर बदल सकते हैं। इस दृष्टिकोण को कभी-कभी अति-विभाजन कहा जाता है।



यह एक पोस्टराइज्ड इमेज की तरह है, जो अनिवार्य रूप से रंगों की संख्या में कमी है। उन्हें फिर से संयोजित करने के लिए (आरएजी)।

निष्कर्ष

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