Finden eines zebraähnlichen Musters im Bild (Erkennung der Mittellinie eines strukturierten Lichtstreifens auf dem Foto)

Ich arbeite in einem Projekt, in dem Ränder gegen ein Motiv projiziert werden und ein Foto aufgenommen wird. Die Aufgabe besteht darin, die Mittellinien der Streifen zu finden, die mathematisch die 3D-Schnittkurve zwischen der Streifenebene und der Objektoberfläche darstellen.

Das Foto ist ein PNG (RGB), und frühere Versuche verwendeten Graustufen- und dann Differenzschwellwerte, um eine zebraähnliche Schwarzweißfotografie zu erhalten, aus der sich der Mittelpunkt jeder Pixelspalte jedes Randes leicht ermitteln ließ. Das Problem ist, dass wir durch Schwellenwertbildung und auch durch Ermitteln der mittleren Höhe einer diskreten Pixelspalte einen Präzisionsverlust und eine Quantisierung haben, die überhaupt nicht erwünscht sind.

Mein Eindruck bei Betrachtung der Bilder ist, dass die Mittellinien kontinuierlicher (mehr Punkte) und glatter (nicht quantisiert) sein könnten, wenn sie durch eine statistische Abtastmethode direkt aus dem Bild ohne Schwellenwert (entweder RGB oder Graustufen) erkannt würden (etwas Überschwemmung / iterative Faltung, was auch immer).

Unten ist ein aktuelles Beispielbild:

Jeder Vorschlag wäre sehr dankbar!

Ich schlage folgende Schritte vor:

1. Suchen Sie eine Schwelle, um den Vordergrund vom Hintergrund zu trennen.
2. Bestimmen Sie für jeden Fleck im Binärbild (jeweils einen Zebrastreifen) xdas gewichtete Zentrum (nach Pixelintensität) in der yRichtung.
3. Möglicherweise glätten Sie die yWerte, um Rauschen zu entfernen.
4. Verbinden Sie die (x,y)Punkte durch Anpassen einer Kurve. Dieser Artikel könnte Ihnen helfen. Sie können auch ein Polynom auf hoher Ebene einsetzen, obwohl es meiner Meinung nach schlimmer ist.

Hier ist ein Matlab-Code, der die Schritte 1, 2 und 4 zeigt. Ich habe die automatische Schwellenwertauswahl übersprungen. Stattdessen habe ich manuell gewählt th=40:

Dies sind die Kurven, die durch Ermitteln des gewichteten Durchschnitts pro Spalte ermittelt werden:

Dies sind die Kurven nach dem Anpassen eines Polynoms:

Hier ist der 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

Ich würde das RGB-Bild nicht verwenden. Farbbilder werden in der Regel durch Anbringen eines "Bayer-Filters" am Kamerasensor erstellt, wodurch die erreichbare Auflösung normalerweise verringert wird.

Wenn Sie das Graustufenbild verwenden, sind die von Ihnen beschriebenen Schritte (Binarisieren des "Zebra" -Bilds, Finden der Mittellinie) ein guter Anfang. Als letzten Schritt würde ich

• Nehmen Sie jeden Punkt in der gefundenen Mittellinie
• nimm die Grauwerte der Pixel in der "Zebra" -Linie oben und unten
• Passen Sie eine Parabel an diese Grauwerte an, indem Sie die kleinsten mittleren Quadrate verwenden
• Die Spitze dieser Parabel ist eine verbesserte Schätzung der Mittellinienposition

Hier finden Sie noch eine alternative Lösung für Ihr Problem, indem Sie Ihre Frage als 'Pfadoptimierungsproblem' modellieren. Es ist zwar komplizierter als die einfache Lösung zur Binarisierung und anschließenden Kurvenanpassung, in der Praxis jedoch robuster.

Von der sehr hohen Ebene aus sollten wir dieses Bild als Grafik betrachten, wo

1. Jedes Bildpixel ist ein Knoten in diesem Diagramm

2. Jeder Knoten ist mit einigen anderen Knoten verbunden, die als Nachbarn bezeichnet werden. Diese Verbindungsdefinition wird häufig als Topologie dieses Diagramms bezeichnet.

3. Jeder Knoten hat ein Gewicht (Feature, Kosten, Energie oder wie auch immer Sie es nennen möchten), was die Wahrscheinlichkeit widerspiegelt, dass sich dieser Knoten in einer optimalen Mittellinie befindet, nach der wir suchen.

Solange wir diese Wahrscheinlichkeit modellieren können, wird Ihr Problem, die "Mittellinien der Streifen" zu finden, zum Problem, lokale optimale Pfade auf dem Graphen zu finden , was durch dynamische Programmierung, z. B. Viterbi-Algorithmus, effektiv gelöst werden kann.

Hier sind einige Vorteile dieses Ansatzes:

1. Alle Ihre Ergebnisse sind kontinuierlich (im Gegensatz zu der Schwellenwertmethode, bei der eine Mittellinie in Stücke gebrochen werden kann).

2. Um ein solches Diagramm zu erstellen, haben Sie viele Freiheiten. Sie können verschiedene Features und Diagrammtopologien auswählen.

3. Ihre Ergebnisse sind optimal im Sinne von Pfadoptimierungen

4. Ihre Lösung ist robuster gegen Rauschen, da diese optimalen Pfade stabil bleiben, solange das Rauschen auf alle Pixel gleichmäßig verteilt ist.

Hier ist eine kurze Demonstration der obigen Idee. Da ich keine Vorkenntnisse verwende, um anzugeben, welche Start- und Endknoten möglich sind, decodiere ich einfach jeden möglichen Startknoten.

Für die Fuzzy-Endungen liegt es daran, dass wir für jeden möglichen Endknoten nach optimalen Wegen suchen. Infolgedessen ist der hervorgehobene Pfad für einige Knoten, die sich in dunklen Bereichen befinden, immer noch der lokal optimale Pfad.

Für den unscharfen Pfad können Sie ihn entweder glätten, nachdem Sie ihn gefunden haben, oder einige geglättete Features anstelle der Rohintensität verwenden.

Es ist möglich, Teilpfade wiederherzustellen, indem Start- und Endknoten geändert werden.

Es wird nicht schwierig sein, diese unerwünschten lokalen optimalen Pfade zu beschneiden. Da wir nach der Viterbi-Dekodierung die Wahrscheinlichkeit haben, dass alle Pfade vorhanden sind, und Sie möglicherweise verschiedene Vorkenntnisse verwenden (z. B. müssen wir für diejenigen, die dieselbe Quelle verwenden, nur einen optimalen Pfad angeben).

Weitere Informationen finden Sie auf dem Papier.

 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.

Hier ist ein kurzer Python-Code, mit dem das obige Diagramm erstellt wird.

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

Ich dachte, ich sollte meine Antwort posten, da sie sich ein bisschen von anderen Ansätzen unterscheidet. Ich habe es in Matlab versucht.

• summieren Sie alle Kanäle und erstellen Sie ein Bild, sodass alle Kanäle gleich gewichtet werden
• Morphologisches Schließen und Gaußsche Filterung für dieses Bild durchführen
• Finden Sie für jede Spalte des resultierenden Bildes die lokalen Maxima und konstruieren Sie ein Bild
• Finden Sie die verbundenen Komponenten dieses Bildes

Ein Nachteil, den ich hier sehe, ist, dass dieser Ansatz für einige Ausrichtungen der Streifen nicht gut funktioniert. In diesem Fall müssen wir die Ausrichtung korrigieren und dieses Verfahren anwenden.

Hier ist der Matlab-Code:

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

Wenn Sie zum Beispiel die mittlere Spalte des Bildes nehmen, sollte das Profil so aussehen: (in Blau ist das Profil. In Grün sind die lokalen Maxima)

Und das Bild mit den lokalen Maxima für alle Spalten sieht folgendermaßen aus:

Hier sind die verbundenen Komponenten (obwohl einige Streifen gebrochen sind, erhalten die meisten von ihnen einen durchgehenden Bereich):