Algorithme le plus rapide pour la transformation de distance

Je recherche l'algorithme le plus rapide disponible pour la transformation de distance.

Selon ce site http://homepages.inf.ed.ac.uk/rbf/HIPR2/distance.htm , il décrit:

La transformation de distance peut être calculée beaucoup plus efficacement en utilisant des algorithmes intelligents en seulement deux passes (par exemple Rosenfeld et Pfaltz 1968).

En cherchant autour, j'ai trouvé: "Rosenfeld, A et Pfaltz, J L. 1968. Fonctions de distance sur les images numériques. Reconnaissance de formes, 1, 33-61."

Mais je pense que nous devrions déjà avoir un algorithme meilleur et plus rapide que celui de 1968? En fait, je n'ai pas pu trouver la source de 1968, donc toute aide est très appréciée.

Pedro F. Felzenszwalb et Daniel P. Huttenlocher ont publié leur implémentation pour la transformation de distance . Vous ne pouvez pas l'utiliser pour des images volumétriques, mais vous pouvez peut-être l'étendre pour prendre en charge les données 3D. Je ne l'ai utilisé que comme boîte noire.

Cet article traite de toutes les transformations de distance exactes modernes:

"2D Euclidean distance transforms: a comparative survey", ACM Computing Surveys, Vol 40, numéro 1, février 2008 http://www.lems.brown.edu/~rfabbri/stuff/fabbri-EDT-survey-ACMCSurvFeb2008.pdf

L'article cite la technique de Meijster, et. Al. comme la transformation exacte la plus polyvalente. Cette technique est détaillée ici:

"Un algorithme général pour calculer les transformations de distance en temps linéaire", A. Meijster, JBTM Roerdink et WH Hesselink. http://fab.cba.mit.edu/classes/S62.12/docs/Meijster_distance.pdf

L'algorithme Meijster est utilisé dans ma bibliothèque d'effets open source: https://github.com/vinniefalco/LayerEffects

J'espère que ça aidera quelqu'un.

Voici un code C # pour la transformation de distance euclidienne au carré 1D selon l'article de 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]]);
    }
}

Cela peut être facilement utilisé pour les images binaires et en niveaux de gris en l'appliquant d'abord sur les colonnes d'images, puis sur les lignes (ou vice versa, bien sûr).

La transformation est en effet très rapide.

Voici les images source et de sortie:

Les pixels noirs ont la valeur 0 et le blanc a une valeur importante (doit être plus grande que la plus grande distance au carré possible dans les images mais pas l'infini) de sorte que la transformation renvoie la distance des pixels noirs et les blancs sont omis.

Pour obtenir une véritable transformation de distance euclidienne, il suffit de prendre une racine carrée de chaque pixel de l'image de sortie.