อัลกอริทึมที่เร็วที่สุดสำหรับการแปลงระยะทาง

ฉันกำลังมองหาอัลกอริทึมที่เร็วที่สุดสำหรับการแปลงระยะทาง

ตามเว็บไซต์นี้http://homepages.inf.ed.ac.uk/rbf/HIPR2/distance.htmเว็บไซต์นี้อธิบาย:

การแปลงระยะทางสามารถคำนวณได้อย่างมีประสิทธิภาพมากขึ้นโดยใช้อัลกอรึทึมที่ชาญฉลาดเพียงแค่สองรอบเท่านั้น (เช่น Rosenfeld และ Pfaltz 1968)

ฉันพบรอบ ๆ : "Rosenfeld, A และ Pfaltz, J L. 1968. ฟังก์ชั่นระยะทางกับภาพดิจิตอลการจดจำรูปแบบ, 1, 33-61"

แต่ฉันเชื่อว่าเราควรมีอัลกอริธึมที่ดีกว่าและเร็วกว่าในปี 1968 หรือไม่? ในความเป็นจริงฉันไม่สามารถหาแหล่งที่มาจากปี 1968 ดังนั้นความช่วยเหลือใด ๆ ที่ชื่นชมอย่างมาก

เปโดรเอฟ Felzenszwalb และแดเนียลพี Huttenlocher มีการเผยแพร่การดำเนินงานของพวกเขาสำหรับระยะเปลี่ยน คุณไม่สามารถใช้มันสำหรับภาพที่มีปริมาตร แต่บางทีคุณสามารถขยายเพื่อรองรับข้อมูล 3d ได้ ฉันใช้มันเป็นกล่องดำเท่านั้น

บทความนี้กล่าวถึงการแปลงระยะทางที่แน่นอนที่ทันสมัยทั้งหมด:

"การแปลงระยะทางแบบยุคลิดแบบ 2D: แบบสำรวจเปรียบเทียบ", แบบสำรวจการคำนวณด้วยคอมพิวเตอร์ ACM, เล่มที่ 40, ฉบับที่ 1, กุมภาพันธ์ 2008 http://www.lems.brown.edu/~rfabbri/stuff/fabbri-EDT-survey-ACMCSurvFeb2008.pdf

กระดาษอ้างอิงเทคนิคจาก Meijster และ อัล เป็นวัตถุประสงค์ทั่วไปที่เร็วที่สุด เทคนิคนี้มีรายละเอียดที่นี่:

"อัลกอริทึมทั่วไปสำหรับการแปลงระยะทางคอมพิวเตอร์ในเวลาเชิงเส้น", A. Meijster, JBTM Roerdink และ WH Hesselink http://fab.cba.mit.edu/classes/S62.12/docs/Meijster_distance.pdf

อัลกอริทึม Meijster ใช้ในไลบรารีเอฟเฟ็กต์โอเพนซอร์สของฉัน: https://github.com/vinniefalco/LayerEffects

ฉันหวังว่านี่จะช่วยให้ใครบางคน

นี่คือรหัส C # สำหรับ 1D ยืดระยะทางยุคลิดเปลี่ยนไปตามกระดาษ 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]]);
    }
}

สามารถใช้สิ่งนี้ได้อย่างง่ายดายสำหรับภาพไบนารีและโทนสีเทาโดยนำไปใช้ก่อนในคอลัมน์ภาพแล้วแถว (หรือในทางกลับกันแน่นอน)

การแปลงร่างเร็วมากจริงๆ

นี่คือภาพต้นฉบับและภาพออก:

พิกเซลสีดำมีค่า 0 และสีขาวมีค่าขนาดใหญ่บางส่วน (จะต้องมีขนาดใหญ่กว่าระยะทางยกกำลังสองที่ใหญ่ที่สุดเท่าที่จะเป็นไปได้ในภาพ แต่ไม่ใช่อินฟินิตี้) เพื่อให้การแปลงเปลี่ยน

เพื่อให้ได้การแปลงระยะทางแบบยุคลิดอย่างแท้จริงเพียงนำสแควร์รูทของแต่ละพิกเซลออกจากภาพที่ส่งออก