1

我有一个A640x1 的单元格。其中每个单元格的值A(i,1)因行而异，例如A(1,1) =[]whileA(2,1)=[1]和A(3,1)=[1,2,3].
还有另一个B大小为 480x640 的矩阵，其中(i)vector的 row_indexA对应于 matrix 的 col_index B。而 vector 中每一行的单元格值A对应于 matrix 中的 row_index B。例如，A(2,1)=[1] 表示 matrix 中的 col_2 row_1 B，而 A(3,1)=[1,2,3] 表示 matrix 中的 col_3 行 1,2&3 B。
我想要做的是对矩阵B中从 vector 引用的每个非零值A，我想检查是否至少有 4 个其他邻居也从 vector 引用A。每个值的邻居数由一个值确定N。
例如，这是矩阵的一部分，B其中所有零“只是为了澄清，事实上它们可能是非零”是像素的邻居，X当N=3：

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的邻居。因此，如果在向量中发现超过 4 个相邻像素，A则执行某些操作，例如G=1，如果没有，则G=0；所以如果有人可以请建议。如果需要进一步澄清，请告诉我。

4

2 回答 2

2

我要做的第一件事是将您的索引单元格转换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)
于 2013-08-26T08:13:26.000 回答
1

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);

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

于 2013-08-26T08:30:34.260 回答