Recherche d'un motif semblable à un zèbre dans l'image (détection de la ligne centrale de la frange de lumière structurée à partir de la photo)

Je travaille sur un projet où des franges sont projetées sur un sujet et une photo est prise. La tâche consiste à trouver les lignes centrales des franges, qui représentent, mathématiquement, la courbe d'intersection 3D entre le plan de la frange et la surface du sujet.

La photo est au format PNG (RVB), et les tentatives précédentes utilisaient des niveaux de gris puis des seuils de différence pour obtenir une photographie en noir et blanc "semblable à un zèbre", à partir de laquelle il était facile de trouver le milieu de chaque colonne de pixels de chaque frange. Le problème est que, par seuillage et également en prenant la hauteur moyenne d'une colonne de pixels discrets, nous avons une perte de précision et une quantification, ce qui n'est pas du tout souhaité.

Mon impression, en regardant les images, est que les traits d'axe pourraient être plus continus (plus de points) et plus lisses (non quantifiés) s'ils étaient détectés directement à partir de l'image sans seuil (RVB ou niveaux de gris), par une méthode de balayage statistique (quelques inondations / convolution itérative, peu importe).

Voici un exemple d'image réel:

Toute suggestion serait très appréciée!

Je suggère les étapes suivantes:

1. Trouvez un seuil pour séparer le premier plan de l'arrière-plan.
2. Pour chaque goutte dans l'image binaire (une bande de zèbre), pour chacune x, trouvez le centre pondéré (par intensité de pixel) dans la ydirection.
3. Éventuellement, lissez les yvaleurs pour éliminer le bruit.
4. Reliez les (x,y)points en ajustant une sorte de courbe. Cet article pourrait vous aider. Vous pouvez également adapter un polynôme de haut niveau, bien que ce soit pire à mon avis.

Voici un code Matlab qui montre les étapes 1, 2 et 4. J'ai ignoré la sélection de seuil automatique. Au lieu de cela, j'ai choisi le manuel th=40:

Voici les courbes que l'on trouve en trouvant la moyenne pondérée par colonne:

Ce sont les courbes après ajustement d'un polynôme:

Voici le code:

function Zebra()
    im = imread('http://i.stack.imgur.com/m0sy7.png');
    im = uint8(mean(im,3));

    th = 40;
    imBinary = im>th;
    imBinary = imclose(imBinary,strel('disk',2));
    % figure;imshow(imBinary);
    labels = logical(imBinary);
    props =regionprops(labels,im,'Image','Area','BoundingBox');

    figure(1);imshow(im .* uint8(imBinary));
    figure(2);imshow(im .* uint8(imBinary));

    for i=1:numel(props)
        %Ignore small ones
        if props(i).Area < 10
            continue
        end
        %Find weighted centroids
        boundingBox = props(i).BoundingBox;
        ul = boundingBox(1:2)+0.5;
        wh = boundingBox(3:4);
        clipped = im( ul(2): (ul(2)+wh(2)-1), ul(1): (ul(1)+wh(1)-1) );
        imClip = double(props(i).Image) .* double(clipped);
        rows = transpose( 1:size(imClip,1) );
        %Weighted calculation
        weightedRows  = sum(bsxfun(@times, imClip, rows),1) ./ sum(imClip,1);
        %Calculate x,y
        x = ( 1:numel(weightedRows) ) + ul(1) - 1;
        y = ( weightedRows ) + ul(2) - 1;
        figure(1);
        hold on;plot(x,y,'b','LineWidth',2);
        try %#ok<TRYNC>
            figure(2);
            [xo,yo] = FitCurveByPolynom(x,y);
            hold on;plot(xo,yo,'g','LineWidth',2);
        end
        linkaxes( cell2mat(get(get(0,'Children'),'Children')) )
    end        
end

function [xo,yo] = FitCurveByPolynom(x,y)
   p = polyfit(x,y,15); 
   yo = polyval(p,x);
   xo = x;
end

Je n'utiliserais pas l'image RVB. Les images en couleur sont généralement réalisées en plaçant un "filtre Bayer" sur le capteur de la caméra, ce qui réduit généralement la résolution que vous pouvez obtenir.

Si vous utilisez l'image en niveaux de gris, je pense que les étapes que vous avez décrites (binariser l'image "zèbre", trouver la ligne médiane) sont un bon début. Enfin, je voudrais

• Prenez chaque point dans la ligne médiane que vous avez trouvée
• prendre les valeurs de gris des pixels dans la ligne "zèbre" au-dessus et en dessous
• adapter une parabole à ces valeurs de gris en utilisant les moindres carrés moyens
• le sommet de cette parabole est une estimation améliorée de la position médiane

Voici encore une solution alternative à votre problème en modélisant votre question comme un «problème d'optimisation de chemin». Bien qu'elle soit plus compliquée que la simple solution de binarisation et d'ajustement de courbe, elle est plus robuste dans la pratique.

Du niveau très élevé, nous devons considérer cette image comme un graphique, où

1. chaque pixel d'image est un nœud sur ce graphique

2. chaque nœud est connecté à d'autres nœuds, appelés voisins, et cette définition de connexion est souvent référée à la topologie de ce graphique.

3. chaque nœud a un poids (fonctionnalité, coût, énergie, ou ce que vous voulez appeler), reflétant la probabilité que ce nœud soit dans une ligne centrale optimale que nous recherchons.

Tant que nous pouvons modéliser cette probabilité, votre problème de trouver `` les lignes centrales des franges '' devient le problème de trouver des chemins locaux optimaux sur le graphique , qui peuvent être résolus efficacement par programmation dynamique, par exemple l'algorithme de Viterbi.

Voici quelques avantages d'adopter cette approche:

1. tous vos résultats seront continus (contrairement à la méthode de seuil qui pourrait casser une ligne centrale en morceaux)

2. beaucoup de libertés pour construire un tel graphique, vous pouvez sélectionner différentes fonctionnalités et la topologie du graphique.

3. vos résultats sont optimaux dans le sens d'optimisations de chemin

4. votre solution sera plus robuste contre le bruit, car tant que le bruit est réparti également entre tous les pixels, ces chemins optimaux restent stables.

Voici une courte démonstration de l'idée ci-dessus. Comme je n'utilise aucune connaissance préalable pour spécifier les nœuds de début et de fin possibles, je décode simplement wrt chaque nœud de départ possible.

Pour les terminaisons floues, cela est dû au fait que nous recherchons des chemins optimaux pour tous les nœuds de terminaison possibles. Par conséquent, bien que pour certains nœuds situés dans des zones sombres, le chemin en surbrillance reste son optimal local.

Pour le chemin flou, vous pouvez soit le lisser après l'avoir trouvé, soit utiliser des fonctions lissées au lieu de l'intensité brute.

Il est possible de restaurer des chemins partiels en modifiant les nœuds de début et de fin.

Il ne sera pas difficile d'élaguer ces chemins optimaux locaux indésirables. Parce que nous avons les probabilités de tous les chemins après le décodage viterbi, et vous pouvez utiliser diverses connaissances antérieures (par exemple, nous voyons qu'il est vrai que nous n'avons besoin que d'un chemin optimal pour ceux qui partagent la même source.)

Pour plus de détails, vous pouvez vous référer au document.

 Wu, Y.; Zha, S.; Cao, H.; Liu, D., & Natarajan, P.  (2014, February). A Markov Chain Line Segmentation Method for Text Recognition. In IS&T/SPIE 26th Annual Symposium on Electronic Imaging (DRR), pp. 90210C-90210C.

Voici un court morceau de code python utilisé pour créer le graphique ci-dessus.

import cv2
import numpy as np
from matplotlib import pyplot
# define your image path
image_path = ;
# read in an image
img = cv2.imread( image_path, 0 );
rgb = cv2.imread( image_path, -1 );

# some feature to reflect how likely a node is in an optimal path
img = cv2.equalizeHist( img ); # equalization
img = img - img.mean(); # substract DC
img_pmax = img.max(); # get brightest intensity
img_nmin = img.min(); # get darkest intensity
# express our preknowledge
img[ img > 0 ] *= +1.0  / img_pmax; 
img[ img = 1 :
    prev_idx = vt_path[ -1 ].astype('int');
    vt_path.append( path_buffer[ prev_idx, time ] );
    time -= 1;
vt_path.reverse();    
vt_path = np.asarray( vt_path ).T;

# plot found optimal paths for every 7 of them
pyplot.imshow( rgb, 'jet' ),
for row in range( 0, h, 7 ) :
    pyplot.hold(True), pyplot.plot( vt_path[row,:], c=np.random.rand(3,1), lw = 2 );
pyplot.xlim( ( 0, w ) );
pyplot.ylim( ( h, 0 ) );

J'ai pensé que je devrais poster ma réponse car elle est un peu différente des autres approches. J'ai essayé cela dans Matlab.

• additionner tous les canaux et créer une image, de sorte que tous les canaux soient pondérés de manière égale
• effectuer la fermeture morphologique et le filtrage gaussien sur cette image
• pour chaque colonne de l'image résultante, trouvez les maxima locaux et construisez une image
• trouver les composants connectés de cette image

Un inconvénient que je vois ici est que cette approche ne fonctionnera pas bien pour certaines orientations des rayures. Dans ce cas, nous devons corriger son orientation et appliquer cette procédure.

Voici le code Matlab:

im = imread('m0sy7.png');
imsum = sum(im, 3); % sum all channels
h = fspecial('gaussian', 3);
im2 = imclose(imsum, ones(3)); % close
im2 = imfilter(im2, h); % smooth
% for each column, find regional max
mx = zeros(size(im2));
for c = 1:size(im2, 2)
    mx(:, c) = imregionalmax(im2(:, c));
end
% find connected components
ccomp = bwlabel(mx);

Par exemple, si vous prenez la colonne centrale de l'image, son profil devrait ressembler à ceci: (en bleu est le profil. En vert sont les maxima locaux)

Et l'image contenant les maxima locaux pour toutes les colonnes ressemble à ceci:

Voici les composants connectés (bien que certaines bandes soient cassées, la plupart d'entre elles ont une région continue):