用Matlab检查相邻像素

Question

我有一个A，它是640x1单元格。其中，每个单元A(i,1)的值在行与行之间变化，例如A(1,1) =[]，而A(2,1)=[1]和A(3,1)=[1,2,3]
存在大小为480x640的另一矩阵B，其中向量A的行索引(i)对应于矩阵B的列索引。而向量CCD_ 10中的每一行的单元值对应于矩阵CCD_。例如，A（2,1）=[1]表示矩阵B中的col_2行_1，而A（3,1）=[1，2，3]表示col_3行1,2&矩阵CCD_ 13中的3
我试图做的是，对于从向量A引用的矩阵B中的每个非零值，我想检查是否至少有4个其他邻居也从向量A引用。每个值的邻居数目由值CCD_ 17确定
例如，这是矩阵B的一部分，其中当N=3:时，所有零"只是为了澄清，因为事实上它们可能是非零"都是像素X的邻居

0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   X   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0
0   0   0   0   0   0   0

如图所示，由于N=3，所有这些零都是像素X的邻居。因此，如果在向量A中发现超过4个相邻像素，则执行某些操作，例如G=1，如果不是，则执行G=0；所以，如果有人可以建议。如果需要更多的澄清，请告诉我。

Answer 1

我要做的第一件事是将索引单元格A转换为逻辑矩阵Amat。这使得检查A中包括多少邻居变得更容易。

以下是使用此转换的解决方案。我希望这些评论足以让人理解。

clear all
clc
nCols = 7;
nRows = 6;
N = 3; %// Number of neighbours
M = 4; %// Minimum number of wanted connections
%// Create cell of indices A
A = cell(nCols,1);
A{1} = [];
A{2} = 1;
A{3} = [1 2 3];
A{4} = [2 5];
A{5} = 3;
A{6} = [3 5];
A{7} = [1 4 6];
%// Generate radom data B
%// (There is a 50% probability for each element of B to be zero)
Bmax = 17;
B = (randi(2,nRows,nCols)-1).*(randi(Bmax,nRows,nCols));
%// Convert the cell A to a logic matrix Amat
Amat = zeros(size(B));
for ii = 1:nCols
    Amat(A{ii},ii) = 1;
end
A
B
Amat
for ii = 1:nCols
    for jj = A{ii}
        if B(jj,ii)>0
            %// Calculate neighbour indices with a lower bound of 1
            %// and an upper bound of nCols or nRows
            col_lim_low = max(1,ii-N);
            col_lim_high = min(nCols,ii+N);
            row_lim_low = max(1,jj-N);
            row_lim_high = min(nRows,jj+N);
            %// Get the corresponding neighbouring-matrix from Amat
            A_neighbours = ...
                Amat(row_lim_low:row_lim_high,col_lim_low:col_lim_high);
            %// Check the number of neighbours against the wanted number M
            if sum(A_neighbours(:)) > 1 + M
                %# do something
                fprintf('We should do something here at (%d,%d)n',jj,ii)
            end
        end
    end
end

以下是一次代码运行的打印输出。

A = 
    []
    [         1]
    [1x3 double]
    [1x2 double]
    [         3]
    [1x2 double]
    [1x3 double]

B =
     1     5     0     0    11     0    16
     0    13    13     0     0     0     9
     0     0     0     5     0     0     0
     3     8    16    16     0     2    12
     0     0     5     0     9     9     0
    12    13     0     6     0    15     0

Amat =
     0     1     1     0     0     0     1
     0     0     1     1     0     0     0
     0     0     1     0     1     1     0
     0     0     0     0     0     0     1
     0     0     0     1     0     1     0
     0     0     0     0     0     0     1
We should do something here at (1,2)
We should do something here at (2,3)
We should do something here at (5,6)
We should do something here at (4,7)

Answer 2

由于A和B之间有一对一的对应关系，因此无需处理A。B是逻辑矩阵（如果在A中未被引用，则为0，如果被引用则为1）。因此，您可以应用一个简单的filter2函数来计算8个最近元素中的活动邻居的数量。

这是代码

B = rand(10,10);                %generate binary matrix
h = [1 1 1;1 0 1;1 1 1];        %filter to be applied
filter2(h,B,'same')>=4 & B>0    %apply filter on B, count minimum of 4 neighbors, if only B>1

---

编辑

为了将单元阵列B转换为二进制存在（0=空，1=不空），使用cellfun是直接的

B = ~cellfun(@isempty,B);

请参阅Armo对您之前关于如何基于A.创建B的问题的回答。