मूल बातें पहले:
मीन शिफ्ट सेगमेंटेशन एक स्थानीय होमोजेनाइजेशन तकनीक है जो स्थानीयकृत वस्तुओं में छायांकन या टॉन्सिलिटी अंतर के लिए बहुत उपयोगी है। एक उदाहरण कई शब्दों से बेहतर है:
क्रिया: प्रत्येक पिक्सेल को एक श्रेणी-आर पड़ोस में पिक्सेल के माध्यम से बदल देता है और जिसका मूल्य दूरी d के भीतर है।
मीन शिफ्ट में आमतौर पर 3 इनपुट लगते हैं:
- पिक्सेल के बीच की दूरी को मापने के लिए एक दूरी समारोह। आमतौर पर यूक्लिडियन दूरी, लेकिन किसी अन्य अच्छी तरह से परिभाषित दूरी फ़ंक्शन का उपयोग किया जा सकता है। मैनहट्टन दूरी कभी कभी एक और उपयोगी विकल्प है।
- एक त्रिज्या। इस त्रिज्या के भीतर सभी पिक्सल (उपरोक्त दूरी के अनुसार मापा जाता है) की गणना के लिए जिम्मेदार होगा।
- एक मूल्य अंतर। त्रिज्या आर के अंदर सभी पिक्सल से, हम केवल उन लोगों को ही लेंगे जिनके मान इस गणना के लिए इस अंतर के भीतर हैं
कृपया ध्यान दें कि एल्गोरिथ्म सीमाओं पर अच्छी तरह से परिभाषित नहीं है, इसलिए विभिन्न कार्यान्वयन आपको वहां अलग-अलग परिणाम देंगे।
मैं यहाँ गौरी गणितीय विवरणों की चर्चा नहीं करूँगा, क्योंकि वे उचित गणितीय संकेतन के बिना दिखाना असंभव हैं, StackOverflow में उपलब्ध नहीं हैं, और इसलिए भी कि वे कहीं और अच्छे स्रोतों से मिल सकते हैं ।
आइए अपने मैट्रिक्स के केंद्र को देखें:
153 153 153 153
147 96 98 153
153 97 96 147
153 153 147 156
त्रिज्या और दूरी के लिए उचित विकल्पों के साथ, चार केंद्र पिक्सल 97 (उनके माध्य) का मान प्राप्त करेंगे और आसन्न पिक्सल का अलग रूप होगा।
इसकी गणना गणितज्ञ करते हैं । वास्तविक संख्या दिखाने के बजाय, हम एक रंग कोडिंग प्रदर्शित करेंगे, इसलिए यह समझना आसान है कि क्या हो रहा है:
आपके मैट्रिक्स के लिए रंग कोडिंग है:
फिर हम एक उचित मीन शिफ्ट लेते हैं:
MeanShiftFilter[a, 3, 3]
और हम प्राप्त करते हैं:
जहां सभी केंद्र तत्व समान हैं (97, BTW)।
आप मीन शिफ्ट के साथ कई बार पुनरावृत्ति कर सकते हैं, अधिक सजातीय रंग प्राप्त करने की कोशिश कर रहे हैं। कुछ पुनरावृत्तियों के बाद, आप एक स्थिर गैर-आइसोट्रोपिक कॉन्फ़िगरेशन पर पहुंचते हैं:
इस समय, यह स्पष्ट होना चाहिए कि आप मीन शिफ्ट को लागू करने के बाद आपको कितने "रंगों" का चयन नहीं कर सकते हैं। तो, आइए दिखाते हैं कि यह कैसे करना है, क्योंकि यह आपके प्रश्न का दूसरा भाग है।
आपको पहले से आउटपुट क्लस्टर्स की संख्या निर्धारित करने में सक्षम होने के लिए कुछ की आवश्यकता है जैसे कि माइग्रेन क्लस्टरिंग ।
यह आपके मैट्रिक्स के लिए इस तरह से चलता है:
b = ClusteringComponents[a, 3]
{{1, 1, 1, 1, 1, 1, 1, 1},
{1, 2, 2, 3, 2, 3, 3, 1},
{1, 3, 3, 3, 3, 3, 3, 1},
{1, 3, 2, 1, 1, 3, 3, 1},
{1, 3, 3, 1, 1, 2, 3, 1},
{1, 3, 3, 2, 3, 3, 3, 1},
{1, 3, 3, 2, 2, 3, 3, 1},
{1, 1, 1, 1, 1, 1, 1, 1}}
या:
जो हमारे पिछले परिणाम के समान है, लेकिन जैसा कि आप देख सकते हैं, अब हमारे पास केवल तीन आउटपुट स्तर हैं।
HTH!