image कैसे Matlab में एक बाइनरी छवि में सभी जुड़े घटकों को खोजने के लिए?



image-processing binary (1)

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

जैसे, आपके मैट्रिक्स को A में संग्रहीत किया गया है, यह मूल एल्गोरिदम है:

  1. एक सरणी को प्रारंभ करें जो कि समान आकार के A है जो logical यह रिकॉर्ड करेगा कि हमने कौन से पिक्सल की जांच की है या दौरा किया है। इसके अलावा एक आउटपुट सरणी B को सभी शून्य में प्रारंभ करें, जो आपको उन सभी जुड़े घटकों को देता है जिन्हें आप चाहते हैं। किसी भी स्थान, जो अंत में शून्य हैं, किसी भी कनेक्टेड घटकों से संबंधित नहीं हैं। साथ ही एक आईडी काउंटर को इनिशियलाइज़ करें, जो इन सभी में से प्रत्येक के साथ जुड़े घटक लेबल का ट्रैक रखता है।

  2. हमारे मैट्रिक्स में प्रत्येक स्थान के लिए:

    ए। यदि स्थान 0 , तो इस स्थान को विज़िट के रूप में चिह्नित करें और जारी रखें।

    ख। यदि हम पहले से ही इस स्थान पर जा चुके हैं, तो जारी रखें।

    सी। अगर हम इस स्थान पर नहीं गए हैं ... चरण # 3 पर जाएं

  3. इस अनजान स्थान को एक स्टैक में जोड़ें।

    ए। जबकि यह स्टैक खाली नहीं है ...

    ख। स्टैक के इस स्थान को बंद करें

    सी। अगर हम इस स्थान पर गए हैं, तो जारी रखें।

    घ। अन्यथा, इस स्थान को विज़िट के रूप में चिह्नित करें और कनेक्ट किए गए घटकों आईडी के साथ इस स्थान को चिह्नित करें।

    ई। इस स्थान को देखते हुए, 8 पड़ोसी पिक्सेल को देखें।

    च। इस सूची में उन पिक्सल को निकालें जिन्हें विज़िट किया गया है, 1 के बराबर या मैट्रिक्स की सीमा से बाहर नहीं

    जी। जो भी स्थान शेष हैं, उन्हें स्टैक में जोड़ें।

  4. स्टैक खाली होने पर, काउंटर बढ़ाना, फिर स्टेप # 2 पर वापस जाएं।

  5. जब तक हम अपने सरणी में सभी स्थानों का दौरा नहीं करते चलते रहें।

आगे की हलचल के बिना, यहां कोड है।

%// Step #1
visited = false(size(A));
[rows,cols] = size(A);
B = zeros(rows,cols);
ID_counter = 1;

%// Step 2
%// For each location in your matrix...
for row = 1 : rows
    for col = 1 : cols
        %// Step 2a
        %// If this location is not 1, mark as visited and continue
        if A(row,col) == 0
            visited(row,col) = true;

        %// Step 2b
        %// If we have visited, then continue
        elseif visited(row,col)
            continue;

        %// Step 2c
        %// Else...
        else
            %// Step 3
            %// Initialize your stack with this location
            stack = [row col];

            %// Step 3a
            %// While your stack isn't empty...
            while ~isempty(stack)
                %// Step 3b
                %// Pop off the stack
                loc = stack(1,:);
                stack(1,:) = [];

                %// Step 3c
                %// If we have visited this location, continue
                if visited(loc(1),loc(2))
                    continue;
                end

                %// Step 3d
                %// Mark location as true and mark this location to be
                %// its unique ID
                visited(loc(1),loc(2)) = true;
                B(loc(1),loc(2)) = ID_counter;

                %// Step 3e
                %// Look at the 8 neighbouring locations
                [locs_y, locs_x] = meshgrid(loc(2)-1:loc(2)+1, loc(1)-1:loc(1)+1);
                locs_y = locs_y(:);
                locs_x = locs_x(:);

                 %%%% USE BELOW IF YOU WANT 4-CONNECTEDNESS
                 % See bottom of answer for explanation
                 %// Look at the 4 neighbouring locations
                 % locs_y = [loc(2)-1; loc(2)+1; loc(2); loc(2)];
                 % locs_x = [loc(1); loc(1); loc(1)-1; loc(1)+1];

                %// Get rid of those locations out of bounds
                out_of_bounds = locs_x < 1 | locs_x > rows | locs_y < 1 | locs_y > cols;

                locs_y(out_of_bounds) = [];
                locs_x(out_of_bounds) = [];

                %// Step 3f
                %// Get rid of those locations already visited
                is_visited = visited(sub2ind([rows cols], locs_x, locs_y));

                locs_y(is_visited) = [];
                locs_x(is_visited) = [];

                %// Get rid of those locations that are zero.
                is_1 = A(sub2ind([rows cols], locs_x, locs_y));
                locs_y(~is_1) = [];
                locs_x(~is_1) = [];

                %// Step 3g
                %// Add remaining locations to the stack
                stack = [stack; [locs_x locs_y]];
            end

            %// Step 4
            %// Increment counter once complete region has been examined
            ID_counter = ID_counter + 1;
        end
    end %// Step 5
 end   

आपके उदाहरण मैट्रिक्स के साथ, मैं B लिए यही मिलता हूं:

B =

     1     1     0     0     0     0     0
     1     1     0     0     2     2     0
     1     1     0     0     0     2     0
     1     1     0     0     0     0     0
     0     0     0     0     0     3     0
     0     0     0     0     0     0     0

4-जुड़े पड़ोस में खोज करने के लिए

4-कनेक्टेड क्षेत्र में खोज करने के लिए कोड को संशोधित करने के लिए, जो कि केवल उत्तर, पूर्व, पश्चिम और दक्षिण में है, उस अनुभाग में जहां आप देखेंगे %// Look at the 8 neighbouring locations , जो है:

 %// Look at the 8 neighbouring locations
 [locs_y, locs_x] = meshgrid(loc(2)-1:loc(2)+1, loc(1)-1:loc(1)+1);
 locs_y = locs_y(:);
 locs_x = locs_x(:);

4-जुड़े हुए फ़ैशन में खोज करने के लिए, आपको केवल इस कोड को केवल उन प्रमुख दिशानिर्देशों को ही संशोधित करना होगा:

 %// Look at the 4 neighbouring locations
locs_y = [loc(2)-1; loc(2)+1; loc(2); loc(2)];
locs_x = [loc(1); loc(1); loc(1)-1; loc(1)+1];

बाकी का कोड अछूता रहता है।

MATLAB के bwlabel फ़ंक्शन का मिलान करने के लिए

यदि आप MATLAB के bwlabel फ़ंक्शन के आउटपुट से मिलान करना चाहते हैं, तो स्तंभ प्रमुख या फोरट्रान ऑर्डर में कनेक्टेड घटकों के लिए bwlabel खोजें। पंक्ति प्रमुख या सी ऑर्डर में उपरोक्त कोड खोज। इसलिए आपको सिर्फ पंक्तियों के बजाय कॉलम के साथ पहले से खोजना होगा, जैसा कि उपरोक्त कोड क्या कर रहा है और आप loops के for दो के ऑर्डर को स्वैप करके करते हैं।

विशेष रूप से, करने के बजाय:

for row = 1 : rows
    for col = 1 : cols
        ....
        ....

तुम करोगे:

for col = 1 : cols
    for row = 1 : rows
        ....
        ....

यह अब bwlabel के आउटपुट को दोहराने चाहिए।

मैं "जुड़े हुए" फ़ंक्शन का उपयोग किए बिना, एक द्विआधारी छवि में 8 पड़ोसियों का उपयोग करके सभी जुड़े हुए घटकों को ढूंढने का प्रयास कर रहा हूं।

उदाहरण के लिए, मेरी इनपुट मैट्रिक्स है:

a =

     1     1     0     0     0     0     0
     1     1     0     0     1     1     0
     1     1     0     0     0     1     0
     1     1     0     0     0     0     0
     0     0     0     0     0     1     0
     0     0     0     0     0     0     0

मुझे ऐसा कुछ करना होगा:

a =

     1     1     0     0     0     0     0
     1     1     0     0     2     2     0
     1     1     0     0     0     2     0
     1     1     0     0     0     0     0
     0     0     0     0     0     3     0
     0     0     0     0     0     0     0

इस छवि में 3 जुड़े ऑब्जेक्ट हैं





connected-components