Schnellster Algorithmus für die Distanztransformation

Ich suche nach dem schnellsten verfügbaren Algorithmus für die Distanztransformation.

Nach dieser Website http://homepages.inf.ed.ac.uk/rbf/HIPR2/distance.htm beschreibt es:

Die Distanztransformation kann mit cleveren Algorithmen in nur zwei Durchgängen wesentlich effizienter berechnet werden (z. B. Rosenfeld und Pfaltz 1968).

Ich suchte herum und fand: "Rosenfeld, A und Pfaltz, J L. 1968. Distanzfunktionen auf digitalen Bildern. Mustererkennung, 1, 33-61."

Aber ich glaube, wir sollten einen besseren und schnelleren Algorithmus haben als den von 1968? Tatsächlich konnte ich die Quelle von 1968 nicht finden, so dass jede Hilfe sehr geschätzt wird.

Pedro F. Felzenszwalb und Daniel P. Huttenlocher haben ihre Implementierung für die Ferntransformation veröffentlicht . Sie können es nicht für volumetrische Bilder verwenden, aber möglicherweise können Sie es erweitern, um 3D-Daten zu unterstützen. Ich habe es nur als Blackbox benutzt.

In diesem Artikel werden alle modernen exakten Distanztransformationen beschrieben:

"2D Euclidean distance transforms: eine vergleichende Umfrage", ACM Computing Surveys, Band 40, Ausgabe 1, Februar 2008 http://www.lems.brown.edu/~rfabbri/stuff/fabbri-EDT-survey-ACMCSurvFeb2008.pdf

Der Aufsatz zitiert die Technik von Meijster et al. al. als schnellster allgemeiner Zweck genaue Transformation. Diese Technik wird hier detailliert beschrieben:

"Ein allgemeiner Algorithmus zur Berechnung von Abstandstransformationen in linearer Zeit", A. Meijster, JBTM Roerdink und WH Hesselink. http://fab.cba.mit.edu/classes/S62.12/docs/Meijster_distance.pdf

Der Meijster-Algorithmus wird in meiner Open Source-Effektbibliothek verwendet: https://github.com/vinniefalco/LayerEffects

Ich hoffe das hilft jemandem.

Hier ist ein C # -Code für eine euklidische Distanztransformation im 1D-Quadrat nach der Arbeit von Felzenszwald & Huttenlocher :

private static void DistanceTransform(double[] dataInput, ref double[] dataOutput)
{
    int n = dataInput.Length;

    int k = 0;
    int[] v = new int[n];
    double[] z = new double[n + 1];

    v[0] = 0;
    z[0] = Double.NegativeInfinity;
    z[1] = Double.PositiveInfinity;

    double s;

    for (int q = 1; q < n; q++)
    {
        while (true)
        {
            s = (((dataInput[q] + q * q) - (dataInput[v[k]] + v[k] * v[k])) / (2.0 * q - 2.0 * v[k]));

            if (s <= z[k])
            {
                k--;
            }
            else
            {
                break;
            }
        }

        k++;

        v[k] = q;
        z[k] = s;
        z[k + 1] = Double.PositiveInfinity;
    }

    k = 0;

    for (int q = 0; q < n; q++)
    {
        while (z[k + 1] < q)
        {
            k++;
        }

        dataOutput[q] = ((q - v[k]) * (q - v[k]) + dataInput[v[k]]);
    }
}

Dies kann leicht für Binär- und Graustufenbilder verwendet werden, indem es zuerst auf Bildspalten und dann auf Zeilen angewendet wird (oder natürlich umgekehrt).

Die Transformation ist in der Tat sehr schnell.

Hier sind die Quell- und Ausgabebilder:

Die schwarzen Pixel haben den Wert 0, und die weißen Pixel haben einen großen Wert (müssen größer sein als der größtmögliche quadratische Abstand in den Bildern, aber nicht unendlich), damit die Transformation den Abstand von den schwarzen Pixeln zurückgibt und die weißen Pixel weggelassen werden.

Um eine echte euklidische Distanztransformation zu erhalten, ziehen Sie einfach eine Quadratwurzel jedes Pixels aus dem Ausgabebild.