Primeiro de tudo, deixe-me claro .. Eu não estou perguntando sobre a malha 2D, para determinar a ordem de enrolamento da malha 2D é muito fácil com a direção normal-z.

Em segundo lugar, não estou pedindo nenhum algoritmo otimizado, não me preocupo com o tempo ou a velocidade, só quero fazer isso com a minha malha.

Quando eu triangulo um objeto 3D usando o algoritmo Greedy Projection Triangulation, esse problema acontece. verifique as imagens anexadas.

Se eu aplicar abordagens 2D a este modelo usando "Calcular área assinada" ou "Produção cruzada de vetores AB e BC de um triângulo", ela só resolve a malha 2D, mas que tal uma malha 3D?

Primeiro, precisamos verificar quais triângulos estão na direção errada do enrolamento na malha 3D, então só consideramos esses triângulos, então a questão é: como podemos verificar quais triângulos estão na direção errada do enrolamento em 3D? Nós não podemos apenas fazer com a abordagem 2D que eu testei e sem sucesso.

Por exemplo, no caso de uma esfera, não podemos aplicar a abordagem 2D à esfera. Então, há alguma maneira de resolver esse problema?

Obrigado.

Atualização 1:

Abaixo está o algoritmo para verificar qual borda tem o mesmo enrolamento. Não funciona bem, não sei porque. Teoricamente, deve corrigir todos os triângulos, mas não está corrigindo. Por exemplo, no caso de uma verificação de esfera na figura em anexo. Algo está errado com isso.

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);
    }
}