Nun, ich musste dieses Remap-Inversionsproblem selbst lösen und werde meine Lösung skizzieren.

Gegeben X , Y für die Funktion remap() , die Folgendes tut:

Ich habe Xinv , Yinv berechnet, das von der Funktion remap() verwendet werden kann, um den Prozess umzukehren:

Zuerst baue ich einen KD-Tree für den 2D-Punktsatz {(X[i,j],Y[i,j]} , damit ich den N nächste Nachbarn zu einem bestimmten Punkt (x,y). Ich verwende euklidische Distanz für meine Distanzmetrik. Ich fand eine großartige C ++ Header-Lib für KD-Trees auf GitHub.

Dann gehe ich durch alle (x,y) -Werte in A 's Gitter und finde die N = 5 nächsten Nachbarn {(X[i_k,j_k],Y[i_k,j_k]) | k = 0 .. N-1} in meinem Punktsatz.

• Wenn distance d_k == 0 für einige k , dann Xinv[x,y] = i_k und Yinv[x,y] = j_k , sonst ...

• Verwenden Sie die Inverse-Distanz-Gewichtung (IDW) , um einen interpolierten Wert zu berechnen:

  • let Gewicht w_k = 1 / pow(d_k, p) (Ich benutze p = 2 )
  • Xinv[x,y] = (sum_k w_k * i_k)/(sum_k w_k)
  • Yinv[x,y] = (sum_k w_k * j_k)/(sum_k w_k)

Beachten Sie, dass, wenn B ein W x H image ist, X und Y W x H Arrays von Floats sind. Wenn A ein w x h image ist, dann sind Xinv und Yinv w x h Arrays für Floats. Es ist wichtig, dass Sie mit der Bild- und Kartengröße übereinstimmen.

Funktioniert wie ein Zauber! In meiner ersten Version habe ich versucht, die Suche brutal zu erzwingen und ich habe nie darauf gewartet, dass es fertig ist. Ich wechselte zu einem KD-Baum, dann begann ich vernünftige Laufzeiten zu bekommen. Wenn ich jemals Zeit bekomme, möchte ich dies zu OpenCV hinzufügen.

Das zweite Bild unten verwendet remap() , um die Linsenverzerrung aus dem ersten Bild zu entfernen. Das dritte Bild ist ein Ergebnis der Invertierung des Prozesses.

< a href="https://i.stack.imgur.com/qhWA4.png">

OP hier. Ich denke, ich habe eine Antwort gefunden. Ich habe es noch nicht implementiert, und wenn jemand mit einer weniger findigen Lösung kommt (oder etwas falsch mit diesem findet), wähle ich stattdessen ihre Antwort.

Problemstellung

Sei A das Quellenbild, B sei das Zielbild und M sei die Abbildung von A's Koordinaten zu B's Koordinaten, d.h.:

... wobei eckige Klammern die Array-Suche mit ganzzahligen Indizes anzeigen und runde Klammern die bilineare Interpolations-Suche mit Gleitkomma-Indizes anzeigen. Wir wiederholen das obige mit der wirtschaftlicheren Notation:

Wir möchten eine inverse Abbildung N finden, die B so gut wie möglich auf A abbildet:

Das Problem kann ohne Bezug auf A oder B angegeben werden:

... Dabei steht ||*|| für die Frobenius-Norm und I_n für die Identitätskarte mit den gleichen Dimensionen wie für N, d. h. für eine Karte mit:

Naive Lösung

Wenn Ms Werte ganze Zahlen sind und M ein Isomorphismus ist, dann können Sie N direkt als:

Oder in unserer vereinfachten Schreibweise:

... wobei I_m die Identitätskarte mit den gleichen Dimensionen wie M ist.

Es gibt zwei Probleme:

1. M ist kein Isomorphismus, daher werden die obigen "Löcher" in N bei N [i, j,:] für jedes [i, j] nicht unter den Werten in M.
belassen
2. Die Werte von M sind Gleitpunktkoordinaten [i, j], keine ganzzahligen Koordinaten. Wir können der bilinear-interpolierten Größe N (i, j, :) für Float-Wert i, j nicht einfach einen Wert zuweisen. Um den äquivalenten Effekt zu erzielen, müssen wir stattdessen die Werte von [i, j] 's vier umgebenden Ecken N [Boden (i), Boden (j),:], N [Boden (i), Ceil (j), :], N [ceil (i), floor (j),:], N [ceil (i), ceil (j),:] so dass der interpolierte Wert N (i, j, :) gleich dem gewünschten Wert [ k, l] für alle Pixelzuordnungen [i, j] - & gt; [k, l] in M.

Lösung

Konstruiere leeres N als 3D Tensor von Schwimmern:

Für jede Koordinate [i, j] im Koordinatenraum von A:

1. Finde das 2x2 Gitter von A-Koordinaten in M, in dem [i, j] liegt. Berechnen Sie die Homographie-Matrix H, die diese A-Koordinaten ihren entsprechenden B-Koordinaten (gegeben durch die Pixelindizes des 2x2-Gitters) zuordnet.
2. Setze N [i, j,:] = Matul (H, [i, j])

Der potentiell teure Schritt hier wäre die Suche in Schritt 1 für das 2x2-Gitter von A-Koordinaten in M, das [i, j] umgibt. Eine Brute-Force-Suche würde diesen ganzen Algorithmus zu O (n * m) machen, wobei n die Anzahl der Pixel in A und m die Anzahl der Pixel in B ist.

Um dies auf O (n) zu reduzieren, könnte man stattdessen einen Scanline-Algorithmus innerhalb jedes A-Koordinaten-Vierecks ausführen, um alle darin enthaltenen ganzzahligen Koordinaten [i, j] zu identifizieren. Dies könnte als hashmap vorberechnet werden, das ganzzahlige A-Koordinaten [i, j] auf die obere linke Ecke der B-Koordinaten des umschließenden Vierecks [k, l] abbildet.