Vérifier les pixels voisins Matlab

Question

J'ai un A qui est une cellule 640x1. où la valeur de chaque cellule A(i,1) varie d'une ligne à l'autre, par exemple A(1,1) =[], tandis que A(2,1)=[1] et A(3,1)=[1,2,3].
Il existe une autre matrice B de taille 480x640, où le vecteur de ROW_INDEX (i)A correspond à la matrice de col_index B. Alors que la valeur de cellule de chaque ligne dans le vecteur A correspond à l'index de ligne dans la matrice B. Par exemple, A (2,1) = [1] cela signifie col_2 ligne_1 dans la matrice B, alors que A (3,1) = [1,2,3] signifie col_3 lignes 1,2 & 3 dans la matrice B. Ce que j'essaye de faire est de pour chaque valeur non-nulle dans la matrice B qui sont référencés du vecteur A, Je veux vérifier s'il y a au moins 4 autres voisins qui sont également référencés du vecteur A. Les nombres voisins de chaque valeur sont déterminés par une valeur N.
Par exemple, ceci est une partie de la matrice B où tous les zéros « juste pour clarifier, comme en fait, ils peuvent être non-zéros » sont les voisins de pixel X lorsque 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 

Comme le montre, parce que N=3, tous ces zéros sont les voisins du pixel X. Donc, si plus de 4 pixels voisins sont trouvés dans le vecteur A, alors faites quelque chose par exemple G=1 sinon G=0; Donc, si quelqu'un pourrait s'il vous plaît aviser. Et s'il vous plaît laissez-moi savoir si d'autres précisions sont nécessaires.

Answer 1

La première chose que je ferais est de convertir votre cellule d'indices A en une matrice logique Amat. Cela facilite le contrôle du nombre de voisins inclus dans A.

Voici une solution qui utilise cette conversion. J'espère que les commentaires sont suffisants pour le rendre compréhensible.

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 

Ce qui suit est une impression d'une exécution du code.

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

Puisque vous avez une à une correspondance entre A et B, il n'y a pas besoin de travailler sur A. B est une matrice logique (0 si elle n'est pas référencée dans A, 1 si référencée). Vous pouvez donc appliquer une fonction filter2 simple en comptant le nombre de voisins actifs dans les 8 éléments les plus proches.

Voici le code

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 

---

EDIT

Pour transformer un réseau de cellules B en présence binaire (0 = vide, 1 = pas vide), l'utilisation de cellfun est simple

B = ~cellfun(@isempty,B); 

Et voir Armo's response à votre question précédente pour savoir comment créer B basé sur A.