Lassen Sie mich zunächst klarstellen. Ich frage nicht nach 2D-Gitternetzen, um die Wicklungsreihenfolge von 2D-Gitternetzen zu bestimmen, ist dies mit Normal-Z-Richtung sehr einfach.

Zweitens frage ich keinen optimierten Algorithmus, ich mache mir keine Sorgen um die Zeit oder die Geschwindigkeit, ich möchte es nur mit meinem Netz tun.

Wenn ich ein 3D-Objekt mit dem Greedy Projection Triangulation-Algorithmus trianguliere, tritt dieses Problem auf. Überprüfen Sie die angehängten Bilder.

Wenn ich für dieses Modell 2D-Ansätze mit "Vorzeichenfläche berechnen" oder "Querproduktion von AB- und BC-Vektoren eines Dreiecks" verwende, wird nur das 2D-Netz gelöst, aber wie wäre es mit einem 3D-Netz?

Zuerst müssen wir überprüfen, welche Dreiecke in 3D-Mesh in der falschen Wickelrichtung sind, dann berücksichtigen wir nur diese Dreiecke. Die Frage ist also, wie wir überprüfen können, welche Dreiecke in 3D in der falschen Wickelrichtung sind. Wir können es nicht nur mit 2D-Ansatz machen, sondern ich habe es getestet und keinen Erfolg.

Zum Beispiel können wir im Falle einer Kugel keine 2D-Annäherung auf eine Kugel anwenden. Gibt es also eine Möglichkeit, dieses Problem zu lösen?

Vielen Dank.

Update Nr. 1:

Unten sehen Sie den Algorithmus, um zu überprüfen, welche Kante die gleiche Wicklung hat. Es funktioniert nicht gut, ich weiß nicht warum. Theoretisch sollte es alle Dreiecke korrigieren, aber es korrigiert nicht. Zum Beispiel im Falle einer Kugelprüfung in der beigefügten Abbildung. Irgendwas stimmt damit nicht.

void GLReversedEdge(int i, int j, GLFace *temp)
{
    //i'th triangle
    int V1 = temp[i].v1;
    int V2 = temp[i].v2;
    int V3 = temp[i].v3;

    //i'th triangle edges
    int E1[] ={V1, V2};
    int E2[] ={V2, V3};
    int E3[] ={V3, V1};

    //adjacent triangle
    int jV1 = temp[j].v1;
    int jV2 = temp[j].v2;
    int jV3 = temp[j].v3;

    //adjacent edges
    int jE1[] ={jV1, jV2};
    int jE2[] ={jV2, jV3};
    int jE3[] ={jV3, jV1};

    // 1st edge of adjacent triangle is checking with all edges of ith triangle
    if((jE1[0] == E1[0] && jE1[1] == E1[1]) ||
       (jE1[0] == E2[0] && jE1[1] == E2[1]) ||
       (jE1[0] == E3[0] && jE1[1] == E3[1]))
    {
       temp[j].set(jV2, jV1, jV3);      // 1st edges orientation is same, so reverse/swap it
    }
    // 2nd edge of adjacent triangle is checking with all edges of ith triangle
    else if((jE2[0] == E1[0] && jE2[1] == E1[1]) ||
            (jE2[0] == E2[0] && jE2[1] == E2[1]) ||
            (jE2[0] == E3[0] && jE2[1] == E3[1]))
    {
            temp[j].set(jV1, jV3, jV2); // 2nd edges orientation is same, so reverse/swap it
    }
    // 3rd edge of adjacent triangle is checking with all edges of ith triangle
    else if((jE3[0] == E1[0] && jE3[1] == E1[1]) ||
            (jE3[0] == E2[0] && jE3[1] == E2[1]) ||
            (jE3[0] == E3[0] && jE3[1] == E3[1]))
    {
            temp[j].set(jV3, jV2, jV1); // 3rd edges orientation is same, so reverse/swap it
    }
}

void GetCorrectWindingOfMesh()
{
    for(int i=0; i<nbF; i++)
    {
        int j1 = AdjacentTriangleToEdgeV1V2;
        if(j1 >= 0) GLReversedEdge(i, j1, temp);

        int j2 = AdjacentTriangleToEdgeV2V3;
        if(j2 >= 0) GLReversedEdge(i, j2, temp);

        int j3 = AdjacentTriangleToEdgeV3V1;
        if(j3 >= 0) GLReversedEdge(i, j3, temp);
    }
}