Skalierung und Rotation unveränderliche Vorlagenübereinstimmung

Ich suche nach einer Methode zur Skalierung und Rotation invarianten Template-Matching. Ich habe bereits einige ausprobiert, aber sie haben für meine Beispiele nicht so gut funktioniert oder dauernd ausgeführt. Die Erkennung von SIFT- und SURF-Features ist vollständig fehlgeschlagen. Ich habe auch versucht, eine Log-Polar-Template-Matching-Funktion zu implementieren, bin aber nie fertig geworden (wusste nicht genau, wie).

In diesen Artikeln

http://cvpr.uni-muenster.de/teaching/ss08/seminarSS08/downloads/Wentker-Vortrag.pdf

http://www.jprr.org/index.php/jprr/article/viewFile/355/148

Ich habe über diese Methode gelesen. Das Kartieren der Polarkoordinaten hat funktioniert, aber ich weiß nicht, ob es richtig ist. Die Bilder sehen so aus.

source_log_polar.png http://www.shareimages.com/images/pics/0/0/3/62394-pZSfl5WenZysnpyVnKg-source_log_polar.png

Und nachdem ich diese 2 Bilder mit OpenCVs Template Matching-Funktion abgeglichen habe, habe ich dieses Ergebnis erhalten

Jetzt weiß ich nicht, wie ich weitermachen soll.

Meine Vorlagen sind immer einfache Symbole beim Erstellen von Blaupausen und der Blaupausen selbst. Die Symbole können sich in Größe und Ausrichtung unterscheiden.

Zum Beispiel meine einfache Blaupause:

Und meine Vorlage

In diesem Beispiel gibt es nur eine Vorlage, aber in den Blaupausen sollten alle Vorkommen gefunden werden, auch diejenigen mit Größen und / oder Ausrichtungen.

Hat jemand einen Ansatz, wie ich das lösen könnte?

Bearbeiten:

Eine Ergänzung zu Andrey Ansatz. Der Entfernungserfassungsalgorithmus für ein radiales Profil. (Mit EmguCV)

private float[] getRadialProfile( Image<Gray, byte> image, Point center, int resolution )
 {

 var roi = image.ROI;

 if ( !roi.Contains( center ) )
  {
   return null;
  }

 var steps = resolution;
 var degreeSteps = 360 / (double)resolution;
 var data = image.Data;
 var peak = 0.0f;
 var bottom = double.MaxValue;
 var bottomIndex = 0;
 var width = roi.Width;
 var height = roi.Height;
 var minX = roi.X;
 var minY = roi.Y;

 float[] distances = new float[resolution];
 for ( var i = 0; i < steps; i++ )
  {
   var degree = i * degreeSteps;
   var radial = degree * Math.PI / 180.0;
   var dy = Math.Sin( radial );
   var dx = Math.Cos( radial );

   var x = (double)center.X;
   var y = (double)center.Y;

   while ( true )
    {
    x += dx;
    y += dy;
    if ( x >= minX + width || y >= minY + height || x <= minX || y <= minY )
     {
      x = -1;
      y = -1;
      break;
     }
    var pixel = data[(int)y, (int)x, 0];
    if ( pixel == 0 )
     {
      break;
     }
    }

    float distance = 0.0f;
    if ( x != -1 && y != -1 )
    {
      distance = (float)Math.Sqrt( Math.Pow( (center.X - x), 2 ) + Math.Pow( (center.Y - y), 2 ) );
    }

    distances[i] = distance;
    if ( distance > peak )
    {
      peak = distance;
    }
    if ( distance < bottom )
    {
      bottom = distance;
      bottomIndex = i;
    }
   }

    // Scale invariance. Divide by peak
   for ( var i = 0; i < distances.Length; i++ )
   {
     distances[i] /= peak;
   }

    // rotation invariance, shift to lowest value
   for ( var i = 0; i < bottomIndex; i++ )
   {
     distances.ShiftLeft(); // Just rotates the array nothing special
   }

   return distances;
}

Ich denke, dass Sie Ihr Problem auf viel einfachere Weise lösen können. Angesichts der Tatsache, dass Sie sich mit Bauplänen befassen, sollten Sie sich keine Gedanken über Edge-Konnektivität, Rauschen und viele andere Dinge machen, für die SIFT und SURF entwickelt wurden. Ihre Vorlage ist eine hohle Form mit bestimmten Kantenformen.

Meine Empfehlung lautet also:

• Gehen Sie um den Umfang herum und finden Sie ein Profil der Abstände der Kanten um die Mitte der Schablone. Dies ist das radiale Profil der Vorlage. Teilen Sie durch den größten Abstand, um skalierungsunabhängig zu sein. Drehen Sie den Vektor so, dass der kleinste Abstand der erste ist, der nicht rotiert. (Wenn Ihre Vorlage keinen dominanten Abstand hat, können Sie Schritt 2 später ändern.)

• Finde Blobs im Bild. Berechnen Sie das in Teil (1) beschriebene radiale Profil und vergleichen Sie die beiden Vektoren durch normalisierte Korrelation. Wenn Ihre Vorlage keinen dominanten Abstand hat, wird die Korrelation zu einer normalisierten Kreuzkorrelation, und es wird das Maximum ausgewählt. Diejenigen, die eine bestimmte Schwelle überschreiten, werden als Treffer gewertet.

Hier ist ein paar Matlab-Codes für den Anfang: Ich habe den Teil geschrieben, der das Entfernungsprofil für einen bestimmten Blob ermittelt und für die Vorlage berechnet:

function Doors
    im = imread('http://i.stack.imgur.com/Tf8EV.png');
    im = im(:,:,1);
    template = imread('http://i.stack.imgur.com/PlP4i.png');
    template = template(:,:,1);

    blobs = regionprops(template>0,'Area','Image');
    largestBlob = GetLargestBlob(blobs);
    [prof,edgeImage] = GetBlobRadialProfile(largestBlob);

    figure;
    subplot(1,2,1);plot(prof); title('Radial profile')
    subplot(1,2,2);imshow(edgeImage); title('Template');

end

function [prof,edgeImage] = GetBlobRadialProfile(blob)
    paddedImage = padarray( blob.Image,[8 8]);
    erodedImage = imerode(paddedImage,strel('disk',1));
    edgeImage = xor(erodedImage,paddedImage);

    c = regionprops(paddedImage,'Centroid');
    cx  = c.Centroid(1);
    cy  = c.Centroid(2);

    [y,x] = find(edgeImage);
    rad = (x(:)-cx).^2 + (y(:)-cy).^2;
    [~,minIndex] = min(rad);
    contour = bwtraceboundary(edgeImage, [y(minIndex), x(minIndex)],'N');
    prof = (contour(:,2)-cx).^2 + (contour(:,1)-cy).^2;
    prof = prof./max(prof);
end

function largestBlob = GetLargestBlob(blobs)    
    area = [blobs.Area];
    [~,index] = max(area);
    largestBlob = blobs(index);
end

Hier ist die Grundidee, was ich weiß, basierend auf einem Vortrag von Professor Anurag Mittal von IIT Madras.

Die Idee ist eine formbasierte Objekterkennung, die natürlich auch an anderer Stelle erweitert werden kann.

1. Kanten mit dem Berkeley-Kantendetektor berechnen.
2. Erhaltene Kanten verbinden. "Globale Objektgrenzenerkennung".
3. Formanpassung mit Fasenabstand oder Houstoff-Abstand.

Sein Artikel darüber ist verfügbar unter: Mehrstufige konturbasierte Erkennung verformbarer Objekte.

Andererseits denke ich, dass SIFT funktionieren sollte, da Eckenerkennungsalgorithmen für die Vorlagenfunktion funktionieren würden, die Sie dort haben.

Hinweis: SIFT ist nicht vollständig rotationsinvariant. Es ist nicht in der Lage, Drehungen> 60 Grad oder so zu bewältigen. Das Bilden mehrerer Vorlagen ist daher eine gute Idee.

Wie bei logarithmisch polarisierten Fourier-Mellin-Transformationen: Sie verursachen Informationsverlust aufgrund der Art und Weise, in der die Transformationen abgetastet werden.

Ich habe nicht viel darüber nachgedacht, aber ich bin mir ziemlich sicher, dass mit klassischen Fourier-Deskriptoren (FD) eine robuste Lösung ohne große Probleme gefunden werden kann. Ich denke, Ihr Problem könnte ein sehr guter Kandidat dafür sein. Denken Sie nicht, dass Sie die Kantenerkennung durchführen müssen, wenn Sie schwarze Strichzeichnungen haben. Beginnen Sie einfach mit dem Raster-Scan, bis Sie auf Pixel treffen, und gehen Sie dann wie folgt vor:

Behandeln Sie Ihren Raumumfang einfach so, als ob es sich um ein 1D-Signal handelt, bei dem die Signalamplitude der normale Abstand zum Schwerpunkt des Objekts ist, der mit einer konstanten Rate abgetastet wird. Machen Sie also ein einfaches FD-Modell für die Tür. Scannen Sie dann die Parameter jedes Raums mit einer Art konvexem Filter, um nach einer ansteigenden Flanke, einer Spitze und einem Abfall zu suchen, wodurch ein Start- / Stopp-Fenster für das zu erfassende "Signal" festgelegt wird. Führen Sie eine FFT oder eine ähnliche FD-Analyse für das erfasste "Signal" durch und vergleichen Sie es mit der FD-Vorlage. Vielleicht kann der Vorlagenvergleichsschritt eine einfache Korrelation mit einem Schwellenwert sein, um eine Übereinstimmung auszulösen. Da nur Ihre Türen runde Kanten haben, sollte dies ein ziemlich einfaches FD-Matching-Problem sein.

Stellen Sie sich vor, Sie würden FDs verwenden, um Bilder oder Musik aus einer Datenbank abzurufen. Viele Whitepapers dazu.

Dies ist ein gutes Tutorial zur Verwendung von FDs zur Approximation von Formen: Ich bezweifle, dass Sie es benötigen, aber Sie können Ihre Bilder auch zunächst in ein Polarkoordinaten-Framework umwandeln, um Rotationen zu verarbeiten, wie in diesem Artikel vorgeschlagen: Formbasiertes Abrufen von Bildern mit generischer Fourier-Deskriptor

Sehen Sie, wie sie FD die Apple-Perimeter-Erkennung parametrisieren? Gleiche Idee wie deine Tür.

Übrigens, ich bin mir ziemlich sicher, dass das Abbilden des gesamten Schemas auf Polarkoordinaten nicht zur Rotationsinvarianz beiträgt. Sie müssten dies für den Schwerpunkt jeder Tür tun, womit Ihr Problem genau beginnt. Aus diesem Grund möchten Sie wahrscheinlich nur Türkandidaten erfassen und diese den Polarkoordinaten zuordnen, um sie mit der FD-Türschablone abzugleichen, wie in dem oben verlinkten Artikel beschrieben.

Lassen Sie mich wissen, wie es geht, wenn Sie diesen Ansatz versuchen.

Vielleicht finden Sie diesen Matlab-Code, den ich geschrieben habe, nützlich: Fraktale Mosaike

Es implementiert das Paper "Robust Image Registration Using Log-Polar Transform" ( pdf ) in eine künstlerische Anwendung, die eine höhere Robustheit als die von mir gefundenen traditionellen Methoden erfordert.