Algoritmo più veloce per la trasformazione a distanza

Sto cercando l'algoritmo più veloce disponibile per la trasformazione a distanza.

Secondo questo sito http://homepages.inf.ed.ac.uk/rbf/HIPR2/distance.htm , descrive:

La trasformazione della distanza può essere calcolata in modo molto più efficiente utilizzando algoritmi intelligenti in soli due passaggi (ad esempio Rosenfeld e Pfaltz 1968).

Cercando in giro, ho trovato: "Rosenfeld, A e Pfaltz, J L. 1968. Funzioni a distanza su immagini digitali. Pattern Recognition, 1, 33-61."

Ma credo che dovremmo avere un algoritmo migliore e più veloce di quello del 1968 già? In effetti, non sono riuscito a trovare la fonte dal 1968, quindi ogni aiuto è molto apprezzato.

Pedro F. Felzenszwalb e Daniel P. Huttenlocher hanno pubblicato la loro implementazione per la trasformazione a distanza . Non puoi usarlo per immagini volumetriche, ma forse puoi estenderlo per supportare i dati 3d. L'ho usato solo come scatola nera.

Questo documento discute tutte le moderne trasformazioni esatte della distanza:

"Trasformazioni 2D della distanza euclidea: un'indagine comparativa", ACM Computing Surveys, Vol 40, Issue 1, Feb 2008 http://www.lems.brown.edu/~rfabbri/stuff/fabbri-EDT-survey-ACMCSurvFeb2008.pdf

L'articolo cita la tecnica di Meijster, et. al. come lo scopo generale più veloce, trasformazione esatta. Questa tecnica è dettagliata qui:

"Un algoritmo generale per il calcolo della distanza si trasforma in tempo lineare", A. Meijster, JBTM Roerdink e WH Hesselink. http://fab.cba.mit.edu/classes/S62.12/docs/Meijster_distance.pdf

L'algoritmo Meijster viene utilizzato nella mia libreria di effetti open source: https://github.com/vinniefalco/LayerEffects

Spero che questo aiuti qualcuno.

Ecco un codice C # per la trasformazione della distanza euclidea al quadrato 1D secondo il documento di 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]]);
    }
}

Questo può essere facilmente usato per le immagini binarie e in scala di grigi applicandolo prima sulle colonne delle immagini e poi sulle righe (o viceversa, ovviamente).

La trasformazione è davvero molto veloce.

Ecco le immagini di origine e di output:

I pixel neri hanno valore 0 e i bianchi hanno un valore maggiore (devono essere più grandi della distanza quadrata possibile più grande nelle immagini ma non l'infinito) in modo che la trasformazione ritorni distanza dai pixel neri e quelli bianchi siano ommigati.

Per ottenere una vera trasformazione della distanza euclidea, basta prendere una radice quadrata di ciascun pixel dall'immagine di output.