http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=21366

which has lots of comments that explains what the code does, and some plots of the graph showing the connected components (graph, as in graph theory). This Puzzler is a fun example of the kind of things dmperm is good for.

(Except that the Code Metrics don’t display properly … sigh).

The code on the File Exchange will have the right name.

[ignore b] = sortrows ([diff(r') a(p(r(1:end-1)))'])
b = b (end) ;

I'll post a file on the File Exchange that's commented so you can see what the algorithm is doing. The non-commented code is:

function c = mySolver (a)
[m n] = size (a) ;
N = m*n ;
k = reshape (1:N, m, n) ;
west  = [(k (:,2:n) .* (a (:,1:n-1) == a (:,2:n))) zeros(m,1)] ;
south = [(k (2:m,:) .* (a (1:m-1,:) == a (2:m,:))) ; zeros(1,n)] ;
W = find (west) ;
S = find (south) ;
t = length (W) + length (S) + N ;
A = sparse ([k(W);k(S);(1:N)'], [west(W);south(S);(1:N)'], ones(t,1), N, N) ;
[p q r s] = dmperm (A+A') ;
[ignore b] = sortrows ([diff(r') a(p(r(1:end-1)))'])
b = b (end) ;
c = zeros (m,n) ;
c (p ([r(b) : r(b+1)-1])) = 1 ;

Thanks for pointing out the glitch.

It’s easy to fix. The size of each component is given by diff(r), where the kth component is nodes p(r(k):r(k+1)-1) where a “node” is an entry in the linear-index order of the image a.

max(diff(r)) just finds the biggest one. It’s a small tweak to pick amongst the ties. I’ll post an update.

There is a problem in your second code. In the case when a zero block is the same size as a non-zero block, your code sometimes returns the zero block.

a = zeros(4) + triu(ones(4)) + diag([-1 -1 0 0])
vs.
a = zeros(4) + triu(ones(4)) + diag([0 0 -1 -1])

http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=11740&objectType=FILE

function c = mySolver (a)
[m n] = size (a) ;
N = m*n ;
k = reshape (1:N, m, n) ;
west  = [(k (:,2:n) .* (a (:,1:n-1) == a (:,2:n))) zeros(m,1)] ;
south = [(k (2:m,:) .* (a (1:m-1,:) == a (2:m,:))) ; zeros(1,n)] ;
W = find (west) ;
S = find (south) ;
t = length (W) + length (S) + N ;
A = sparse ([k(W);k(S);(1:N)'], [west(W);south(S);(1:N)'], ones(t,1), N, N) ;
[p q r s] = dmperm (A+A') ;
[siz b] = max (diff (r)) ;
c = zeros (m,n) ;
c (p ([r(b) : r(b+1)-1])) = 1 ;

function c = mySolver (a)
%MYSOLVER find the largest nonzero connected component
[m n] = size (a) ;
N = m*n ;
k = reshape (1:N, m, n) ;
west  = [(k (:,2:n) .* (a (:,1:n-1) == a (:,2:n))) zeros(m,1)] ;
south = [(k (2:m,:) .* (a (1:m-1,:) == a (2:m,:))) ; zeros(1,n)] ;
W = find (west) ;
S = find (south) ;
A = sparse ([k(W);k(S);(1:N)'], [west(W);south(S);(1:N)'], [a(W);a(S);(1:N)'], N, N) ;
[p q r s] = dmperm (A+A') ;
[siz b] = max (diff (r)) ;
c = zeros (m,n) ;
c (p ([r(b) : r(b+1)-1])) = 1 ;

Here are some timings. With

a = round (rand (2000)*9) ;

The code above takes just under 9 seconds, which is about 20 times faster than at least one of the earlier posts. “dmperm” is also what the Image Processing Toolbox uses. This code uses dmperm directly.

Hey Doug, I don’t have access to the toolboxes where I work yet, could you just say a little about how our (the non-toolbox folks) solutions compare speed-wise and scale-wise to the code using the toolboxes?

Also, speaking of scaling, I ran the profiler and found the bottleneck in my code, it was mostly the find statement at the end. I spent a few minutes fixing it, and now it is way faster. Especially for a larger problems, for example:

 
a = round(rand(500)*9);
tic,ms = mySolver(a);toc
Elapsed time is 0.717184 seconds.
 

This compares with about 50 seconds for my first crack at it! This simply proves that a few minutes spent profiling can pay off big time.
Here is the code:

 
function [c] = mySolver(a)
%MYSOLVER finds the largest island of four-connected elements.
[row,col] = size(a);
tmp = [nan(row,1),a]; % Pad with NaNs.
tmp = [nan(1,col+1);tmp];
c = zeros(size(tmp)); % Mark the groups.
d = zeros(1,ceil(numel(a)/2)); % Hold the value of each group.
ln = d; % Hold the number of elements in each group.
cntr = 1; % Label the individual groups.

for ii = 2:row+1;
    for jj = 1:col;
        if tmp(ii,jj)==tmp(ii,jj+1) % look right.
            if tmp(ii,jj)==tmp(ii-1,jj+1) % look right-up diag.
                if ~c(ii-1,jj+1) && ~c(ii,jj)
                    c(ii,jj) = cntr;
                    c(ii-1,jj+1) = cntr;
                    c(ii,jj+1) = cntr;
                    d(cntr) = a(ii-1,jj-1);
                    ln(cntr) = ln(cntr) + 3;
                    cntr = cntr + 1;
                elseif ~c(ii-1,jj+1)
                    c(ii-1,jj+1) = c(ii,jj);
                    c(ii,jj+1) = c(ii,jj);
                    ln(c(ii,jj)) = ln(c(ii,jj)) + 2;
                elseif ~c(ii,jj)
                    c(ii,jj) = c(ii-1,jj+1);
                    c(ii,jj+1) = c(ii-1,jj+1);
                    ln(c(ii-1,jj+1)) = ln(c(ii-1,jj+1)) + 2;
                else
                    idx = c(ii-1,jj+1); % Save this for now.
                    vct = c==c(ii-1,jj+1);
                    lnv = find(vct);
                    c(vct)=c(ii,jj);
                    c(ii,jj+1) = c(ii,jj);
                    ln(c(ii,jj)) = ln(c(ii,jj)) +  length(lnv)+1;
                    ln(idx) = ln(idx) - length(lnv);
                end
            elseif ~c(ii,jj)
                c(ii,jj) = cntr;
                c(ii,jj+1) = cntr;
                d(cntr) = a(ii-1,jj-1);
                ln(cntr) = ln(cntr) + 2;
                cntr = cntr+1;
            else
                c(ii,jj+1) = c(ii,jj);
                ln(c(ii,jj)) = ln(c(ii,jj)) + 1;
            end
        elseif tmp(ii,jj+1)==tmp(ii-1,jj+1) % look right-up diag.
            if ~c(ii-1,jj+1)
                c(ii,jj+1) = cntr;
                c(ii-1,jj+1) = cntr;
                d(cntr) = a(ii-1,jj);
                ln(cntr) = ln(cntr) + 2;
                cntr = cntr + 1;
            else
                c(ii,jj+1) = c(ii-1,jj+1);
                ln(c(ii-1,jj+1)) = ln(c(ii-1,jj+1)) + 1;
            end
        end
    end
end

clear tmp % free up memory.
c = c(2:end,2:end); % Remove padding.
idx = ln==max(ln); % Find the largest num of elements.
[idx2,idx2] = max(d(idx)); % And corresponding values.
grp = find(idx,idx2); % Make selection.
c(c~=grp(end)) = 0;  % Final matrix.
c(c==grp(end)) = 1;
 

At this point I will leave it up as is, since I made a mistake in the problem statement. Instead of “positive whole numbers” I should have said “nonnegative integers” (0, 1, 2, 3,…)

Thanks for keeping me honest on terminology, once I get your address, a bunch of MATLAB swag will be on its way!

Thanks,
Doug