imresize - versuchen zu verstehen, die bikubische interpolation

Dies ist eine Art von follow-up auf Ihre Vorherige Fragen über den Unterschied zwischen imresize in MATLAB und cv::resize in OpenCV gegeben eine bikubische interpolation.

War ich interessiert, mich heraus zu finden, warum es einen Unterschied. Dies sind meine Erkenntnisse (wie ich verstanden habe die algorithmen, bitte korrigieren Sie mich, wenn ich keine Fehler machen).

Denken, zum ändern der Größe eines Bilds als eine planare transformation von ein Eingabebild der Größe M-by-N zu einem ausgabebild der Größe scaledM-by-scaledN.

Das problem ist, dass die Punkte nicht unbedingt passen auf das diskrete Gitter, daher erhalten Intensitäten der Pixel im ausgabebild, müssen wir interpolieren die Werte von einigen der benachbarten Proben (in der Regel erfolgt in umgekehrter Reihenfolge, das heißt für jeden pixel-Ausgabe, finden wir den entsprechenden nicht-ganzzahlige Punkt in der input-Raum und interpolieren um ihn herum).

Dies ist, wo Interpolations-algorithmen unterscheiden sich durch die Wahl der Größe der Nachbarschaft und die Gewichts-Koeffizienten geben zu jedem Punkt in dieser Gegend. Die Beziehung kann Erster oder höherer Ordnung (wobei die variable beteiligt ist der Abstand von der inverse-Mapping-non-integer Beispiel auf der diskreten Punkte auf der original-Bild-raster). In der Regel weisen Sie höhere GEWICHTE, um näher Punkte.

Blick auf imresize in MATLAB, hier sind die GEWICHTE von Funktionen für die lineare und kubische Kernel:

function f = triangle(x)
    % or simply: 1-abs(x) for x in [-1,1]
    f = (1+x) .* ((-1 <= x) & (x < 0)) + ...
        (1-x) .* ((0 <= x) & (x <= 1));
end

function f = cubic(x)
    absx = abs(x);
    absx2 = absx.^2;
    absx3 = absx.^3;
    f = (1.5*absx3 - 2.5*absx2 + 1) .* (absx <= 1) + ...
        (-0.5*absx3 + 2.5*absx2 - 4*absx + 2) .* ((1 < absx) & (absx <= 2));
end

(Diese im Grunde die Rückkehr der interpolation Gewicht einer Probe auf der Grundlage, wie weit es ist, von einem interpolierten Punkt).

Dies ist, wie diese Funktionen Aussehen:

>> subplot(121), ezplot(@triangle,[-2 2])  % triangle
>> subplot(122), ezplot(@cubic,[-3 3])     % Mexican hat

Beachten Sie, dass der linear-kernel (stückweise lineare Funktionen auf [-1,0] und [0,1] Intervalle, und Nullen an anderer Stelle) arbeitet auf der 2-benachbarten Punkte, während die kubische kernel (stückweise kubische Funktionen auf die Intervalle [-2,-1], [-1,1], und [1,2], Nullen und anderswo) funktioniert auf 4 benachbarte Punkte.

Hier ist eine illustration für den 1-dimensionalen Fall, der zeigt, wie man interpoliert den Wert x aus den diskreten Punkte f(x_k) mit Hilfe einer kubischen kernel:

Die kernel-Funktion h(x) ist ausgerichtet auf x die Lage der Punkt interpoliert werden. Der interpolierte Wert f(x) ist die gewichtete Summe der benachbarten diskreten Punkten (2 Links und 2 rechts), skaliert durch den Wert der interpolation der Funktion an diesen diskreten Punkten.

Sagen, wenn der Abstand zwischen x und der nächste Punkt ist d (0 <= d < 1), der interpolierte Wert an der Stelle x werden:

f(x) = f(x1)*h(-d-1) + f(x2)*h(-d) + f(x3)*h(-d+1) + f(x4)*h(-d+2)

wo die Reihenfolge der Punkte ist wie folgt (beachten Sie, dass x(k+1)-x(k) = 1):

x1      x2   x    x3       x4
o--------o---+----o--------o
         \___/
       distance d

Nun, da die Punkte diskret sind und die Stichprobe in gleichmäßigen Abständen, und die kernel-weite ist in der Regel klein ist, wird die interpolation kann formuliert werden, die kurz und prägnant als convolution Betrieb:

Das Konzept erstreckt sich auf 2 Dimensionen einfach, indem Sie zuerst die Interpolation entlang einer dimension, und dann die Interpolation auf der anderen dimension mit den Ergebnissen der vorherigen Schritt.

Hier ist ein Beispiel für die Bilineare interpolation, die in der 2D-Ansicht 4 benachbarten Punkte:

Wird die bikubische interpolation in 2D verwendet 16 benachbarte Punkte:

Zuerst haben wir interpolieren entlang der Zeilen (die roten Punkte) mit dem 16 grid-Muster (pink). Dann haben wir interpolieren entlang der anderen dimension (rote Linie) mit den interpolierten Punkte aus dem vorherigen Schritt. In jedem Schritt, ist eine regelmäßige 1D-interpolation durchgeführt wird. In diese Gleichungen sind zu lang und kompliziert für mich zu arbeiten von hand!

Nun, wenn wir gehen zurück zu den cubic Funktion in MATLAB, es tatsächlich entspricht die definition des convolution-Kernels gezeigt, in der Referenz-Papier wie Gleichung (4). Hier ist die gleiche Sache genommen von Wikipedia:

Können Sie sehen, dass in der obigen definition, MATLAB wählte einen Wert von a=-0.5.

Nun der Unterschied zwischen der Implementierung in MATLAB und OpenCV ist, dass OpenCV wählte einen Wert von a=-0.75.

static inline void interpolateCubic( float x, float* coeffs )
{
    const float A = -0.75f;

    coeffs[0] = ((A*(x + 1) - 5*A)*(x + 1) + 8*A)*(x + 1) - 4*A;
    coeffs[1] = ((A + 2)*x - (A + 3))*x*x + 1;
    coeffs[2] = ((A + 2)*(1 - x) - (A + 3))*(1 - x)*(1 - x) + 1;
    coeffs[3] = 1.f - coeffs[0] - coeffs[1] - coeffs[2];
}

Dies ist vielleicht nicht sofort klar, aber den code nicht berechnen, die Begriffe der cubic-convolution-Funktion (aufgelistet nach rechts nach Gleichung (25) in der Papier -):

Können wir sicherstellen, dass mit Hilfe der Symbolic Math Toolbox:

A = -0.5;
syms x
c0 = ((A*(x + 1) - 5*A)*(x + 1) + 8*A)*(x + 1) - 4*A;
c1 = ((A + 2)*x - (A + 3))*x*x + 1;
c2 = ((A + 2)*(1 - x) - (A + 3))*(1 - x)*(1 - x) + 1;
c3 = 1 - c0 - c1 - c2;

Diese Ausdrücke können wie folgt umgeschrieben werden:

>> expand([c0;c1;c2;c3])
ans =
       - x^3/2 + x^2 - x/2
 (3*x^3)/2 - (5*x^2)/2 + 1
 - (3*x^3)/2 + 2*x^2 + x/2
             x^3/2 - x^2/2

die den Begriffen entsprechen, die aus der obigen Gleichung.

Offensichtlich der Unterschied zwischen MATLAB und OpenCV läuft darauf hinaus, mit einem anderen Wert für die freie Sicht a. Nach Ansicht der Autoren des Papiers, ein Wert von 0.5 ist die bevorzugte Wahl, da es impliziert, dass bessere Eigenschaften für die approximation-Fehler als jede andere Wahl für a.