Noktalar saat yönünde sıralansın mı?

Bir x, y noktası dizisi verildiğinde, bu dizinin noktalarını saat yönünde (genel ortalama merkez noktalarının çevresinde) nasıl sıralayabilirim? Amacım, çizgileri bir çizgi oluşturma işlevine geçirerek oldukça "katı" görünen bir şeyle sonuçlanmak ve mümkün olduğunca dışbükey çizgiler olmadan kesmektir.

Değer için, Lua kullanıyorum, ancak herhangi bir sahte kod takdir edilecektir.

Güncelleme: Referans için, bu Ciamej'in mükemmel cevabına dayanan Lua kodu (benim "uygulama" önekimi yoksay)

function appSortPointsClockwise(points)
    local centerPoint = appGetCenterPointOfPoints(points)
    app.pointsCenterPoint = centerPoint
    table.sort(points, appGetIsLess)
    return points
end

function appGetIsLess(a, b)
    local center = app.pointsCenterPoint

    if a.x >= 0 and b.x < 0 then return true
    elseif a.x == 0 and b.x == 0 then return a.y > b.y
    end

    local det = (a.x - center.x) * (b.y - center.y) - (b.x - center.x) * (a.y - center.y)
    if det < 0 then return true
    elseif det > 0 then return false
    end

    local d1 = (a.x - center.x) * (a.x - center.x) + (a.y - center.y) * (a.y - center.y)
    local d2 = (b.x - center.x) * (b.x - center.x) + (b.y - center.y) * (b.y - center.y)
    return d1 > d2
end

function appGetCenterPointOfPoints(points)
    local pointsSum = {x = 0, y = 0}
    for i = 1, #points do pointsSum.x = pointsSum.x + points[i].x; pointsSum.y = pointsSum.y + points[i].y end
    return {x = pointsSum.x / #points, y = pointsSum.y / #points}
end

İlk olarak, orta noktayı hesaplayın. Ardından, istediğiniz sıralama algoritmasını kullanarak noktaları sıralayın, ancak bir noktanın diğerinden daha az olup olmadığını belirlemek için özel karşılaştırma rutini kullanın.

Bu basit hesaplama ile bir noktanın (a) merkezle ilişkili olarak diğerinin (b) solunda mı yoksa sağında mı olduğunu kontrol edebilirsiniz:

det = (a.x - center.x) * (b.y - center.y) - (b.x - center.x) * (a.y - center.y)

eğer sonuç sıfırsa, o zaman merkezden aynı çizgidedirler, eğer pozitif veya negatifse, o zaman bir tarafta veya diğerinde, yani bir nokta diğerinden önce gelir. Bunu kullanarak noktaları karşılaştırmak ve sıralı dizide hangi sırayla görünmeleri gerektiğini belirlemek için küçük bir ilişki kurabilirsiniz. Ancak bu düzenin başlangıcı nerede olduğunu tanımlamanız gerekir, yani başlangıç ​​açısının hangi açı olacağını (örneğin, x ekseninin pozitif yarısı).

Karşılaştırma işlevinin kodu şöyle görünebilir:

bool less(point a, point b)
{
    if (a.x - center.x >= 0 && b.x - center.x < 0)
        return true;
    if (a.x - center.x < 0 && b.x - center.x >= 0)
        return false;
    if (a.x - center.x == 0 && b.x - center.x == 0) {
        if (a.y - center.y >= 0 || b.y - center.y >= 0)
            return a.y > b.y;
        return b.y > a.y;
    }

    // compute the cross product of vectors (center -> a) x (center -> b)
    int det = (a.x - center.x) * (b.y - center.y) - (b.x - center.x) * (a.y - center.y);
    if (det < 0)
        return true;
    if (det > 0)
        return false;

    // points a and b are on the same line from the center
    // check which point is closer to the center
    int d1 = (a.x - center.x) * (a.x - center.x) + (a.y - center.y) * (a.y - center.y);
    int d2 = (b.x - center.x) * (b.x - center.x) + (b.y - center.y) * (b.y - center.y);
    return d1 > d2;
}

Bu, noktaları saat 12'den başlayarak saat yönünde sıralayacaktır. Aynı "saat" üzerindeki puanlar, merkezden daha ileri olanlardan başlanarak sıralanacaktır.

Tamsayı türlerini (Lua'da gerçekten mevcut olmayan) kullanıyorsanız, det, d1 ve d2 değişkenlerinin gerçekleştirilen hesaplamaların sonucunu tutabilecek türde olduğundan emin olmanız gerekir.

Mümkün olduğunca dışbükey görünen sağlam bir şey elde etmek istiyorsanız, sanırım bir Dışbükey Gövde arıyorsunuz . Graham Scan'i kullanarak hesaplayabilirsiniz . Bu algoritmada, noktaları özel bir pivot noktasından başlayarak saat yönünde (veya saat yönünün tersine) sıralamanız gerekir. Ardından, dışbükey gövdeye yeni noktalar ekleyerek sola veya sağa dönüp dönmediğinizi kontrol ederken her seferinde basit döngü adımlarını tekrarlarsınız, bu kontrol yukarıdaki karşılaştırma işlevinde olduğu gibi bir çapraz ürüne dayanır.

Düzenle:

if (a.y - center.y >= 0 || b.y - center.y >=0)X = 0 ve y negatif olan noktaların, merkezden daha ileri noktalardan başlayarak sıralandığından emin olmak için bir if ifadesi daha eklendi . Aynı 'saatte' puanların sırasını umursamıyorsanız, if ifadesini atlayabilir ve her zaman geri dönebilirsiniz a.y > b.y.

Ekleyerek ifadeleri ise ilk düzeltildi -center.xve -center.y.

İkinci if ifadesi eklendi (a.x - center.x < 0 && b.x - center.x >= 0). Eksik olduğu açık bir gözetimdi. Bazı denetimler gereksiz olduğu için if ifadeleri şimdi yeniden düzenlenebilir. Örneğin, ilk if ifadesindeki ilk koşul yanlışsa, ikincisinin ilk koşulu doğru olmalıdır. Ancak, basitlik uğruna olduğu gibi kodu bırakmaya karar verdim. Derleyicinin kodu optimize etmesi ve yine de aynı sonucu üretmesi oldukça olasıdır.

Sorununuza ilginç bir alternatif yaklaşım, Gezgin Satıcı Sorunu (TSP) için yaklaşık minimum değeri bulmak olacaktır. tüm puanlarınızı birbirine bağlayan en kısa yol. Noktalarınız dışbükey bir şekil oluşturuyorsa, doğru çözüm olmalıdır, aksi halde yine de iyi görünmelidir ("katı" bir şekil düşük bir çevre / alan oranına sahip olarak tanımlanabilir, bu da burada optimize ediyoruz) .

Tercih ettiğiniz dilde bir ton bulabileceğinizden emin olduğum TSP için herhangi bir optimize edici uygulamasını kullanabilirsiniz.

İstediğiniz, kutupsal koordinatlar olarak bilinen bir sistemdir . Kartezyen'den kutupsal koordinatlara dönüşüm her dilde kolayca yapılabilir. Formüller bu bölümde bulunabilir .

Kutupsal koordinatlara dönüştürdükten sonra, teta açısına göre sıralayın.

Başka bir sürüm (a, b'den önce saat yönünün tersine gelirse true değerini döndürür):

    bool lessCcw(const Vector2D &center, const Vector2D &a, const Vector2D &b) const
    {
        // Computes the quadrant for a and b (0-3):
        //     ^
        //   1 | 0
        //  ---+-->
        //   2 | 3

        const int dax = ((a.x() - center.x()) > 0) ? 1 : 0;
        const int day = ((a.y() - center.y()) > 0) ? 1 : 0;
        const int qa = (1 - dax) + (1 - day) + ((dax & (1 - day)) << 1);

        /* The previous computes the following:

           const int qa =
           (  (a.x() > center.x())
            ? ((a.y() > center.y())
                ? 0 : 3)
            : ((a.y() > center.y())
                ? 1 : 2)); */

        const int dbx = ((b.x() - center.x()) > 0) ? 1 : 0;
        const int dby = ((b.y() - center.y()) > 0) ? 1 : 0;
        const int qb = (1 - dbx) + (1 - dby) + ((dbx & (1 - dby)) << 1);

        if (qa == qb) {
            return (b.x() - center.x()) * (a.y() - center.y()) < (b.y() - center.y()) * (a.x() - center.x());
        } else {
            return qa < qb;
       } 
    }

Bu daha hızlıdır, çünkü derleyici (Visual C ++ 2015'te test edilmiştir) dax, day, dbx, dby'yi hesaplamak için atlama üretmez. İşte derleyiciden çıktı düzeneği:

; 28   :    const int dax = ((a.x() - center.x()) > 0) ? 1 : 0;

    vmovss  xmm2, DWORD PTR [ecx]
    vmovss  xmm0, DWORD PTR [edx]

; 29   :    const int day = ((a.y() - center.y()) > 0) ? 1 : 0;

    vmovss  xmm1, DWORD PTR [ecx+4]
    vsubss  xmm4, xmm0, xmm2
    vmovss  xmm0, DWORD PTR [edx+4]
    push    ebx
    xor ebx, ebx
    vxorps  xmm3, xmm3, xmm3
    vcomiss xmm4, xmm3
    vsubss  xmm5, xmm0, xmm1
    seta    bl
    xor ecx, ecx
    vcomiss xmm5, xmm3
    push    esi
    seta    cl

; 30   :    const int qa = (1 - dax) + (1 - day) + ((dax & (1 - day)) << 1);

    mov esi, 2
    push    edi
    mov edi, esi

; 31   : 
; 32   :    /* The previous computes the following:
; 33   : 
; 34   :    const int qa =
; 35   :        (   (a.x() > center.x())
; 36   :         ? ((a.y() > center.y()) ? 0 : 3)
; 37   :         : ((a.y() > center.y()) ? 1 : 2));
; 38   :    */
; 39   : 
; 40   :    const int dbx = ((b.x() - center.x()) > 0) ? 1 : 0;

    xor edx, edx
    lea eax, DWORD PTR [ecx+ecx]
    sub edi, eax
    lea eax, DWORD PTR [ebx+ebx]
    and edi, eax
    mov eax, DWORD PTR _b$[esp+8]
    sub edi, ecx
    sub edi, ebx
    add edi, esi
    vmovss  xmm0, DWORD PTR [eax]
    vsubss  xmm2, xmm0, xmm2

; 41   :    const int dby = ((b.y() - center.y()) > 0) ? 1 : 0;

    vmovss  xmm0, DWORD PTR [eax+4]
    vcomiss xmm2, xmm3
    vsubss  xmm0, xmm0, xmm1
    seta    dl
    xor ecx, ecx
    vcomiss xmm0, xmm3
    seta    cl

; 42   :    const int qb = (1 - dbx) + (1 - dby) + ((dbx & (1 - dby)) << 1);

    lea eax, DWORD PTR [ecx+ecx]
    sub esi, eax
    lea eax, DWORD PTR [edx+edx]
    and esi, eax
    sub esi, ecx
    sub esi, edx
    add esi, 2

; 43   : 
; 44   :    if (qa == qb) {

    cmp edi, esi
    jne SHORT $LN37@lessCcw

; 45   :        return (b.x() - center.x()) * (a.y() - center.y()) < (b.y() - center.y()) * (a.x() - center.x());

    vmulss  xmm1, xmm2, xmm5
    vmulss  xmm0, xmm0, xmm4
    xor eax, eax
    pop edi
    vcomiss xmm0, xmm1
    pop esi
    seta    al
    pop ebx

; 46   :    } else {
; 47   :        return qa < qb;
; 48   :    }
; 49   : }

    ret 0
$LN37@lessCcw:
    pop edi
    pop esi
    setl    al
    pop ebx
    ret 0
?lessCcw@@YA_NABVVector2D@@00@Z ENDP            ; lessCcw

Zevk almak.

• vektör3 a = yeni vektör3 (1, 0, 0) .............. wrt X_axis
• vektör3 b = any_point - Merkez;

- y = |a * b|   ,   x =  a . b

- Atan2(y , x)...............................gives angle between -PI  to  + PI  in radians
- (Input % 360  +  360) % 360................to convert it from  0 to 2PI in radians
- sort by adding_points to list_of_polygon_verts by angle  we got 0  to 360

Sonunda Anticlockwize sıralanmış verts olsun

list.Reverse () .................. Clockwise_order