path: root/thirdparty/thekla_atlas/nvmesh/param/Util.cpp

// This code is in the public domain -- castano@gmail.com

#include "nvmesh.h" // pch

#include "Util.h"

#include "nvmesh/halfedge/Mesh.h"
#include "nvmesh/halfedge/Face.h"
#include "nvmesh/halfedge/Vertex.h"

#include "nvmath/Vector.inl"

#include "nvcore/Array.inl"


using namespace nv;

// Determine if the given mesh is a	quad mesh.
bool nv::isQuadMesh(const HalfEdge::Mesh * mesh)
{
    nvDebugCheck(mesh != NULL);

    const uint faceCount = mesh->faceCount();
    for(uint i = 0; i < faceCount; i++) {
        const HalfEdge::Face * face = mesh->faceAt(i);
        if (face->edgeCount() != 4) {
            return false;
        }
    }

    return true;
}

bool nv::isTriangularMesh(const HalfEdge::Mesh * mesh)
{
    for (HalfEdge::Mesh::ConstFaceIterator it(mesh->faces()); !it.isDone(); it.advance())
    {
        const HalfEdge::Face * face = it.current();
        if (face->edgeCount() != 3) return false;
    }
    return true;
}


uint nv::countMeshTriangles(const HalfEdge::Mesh * mesh)
{
    const uint faceCount = mesh->faceCount();

    uint triangleCount = 0;

    for (uint f = 0; f < faceCount; f++)
    {
        const HalfEdge::Face * face = mesh->faceAt(f);
        
        uint edgeCount = face->edgeCount();
        nvDebugCheck(edgeCount > 2);

        triangleCount += edgeCount - 2;
    }

    return triangleCount;
}

const HalfEdge::Vertex * nv::findBoundaryVertex(const HalfEdge::Mesh * mesh)
{
    const uint vertexCount = mesh->vertexCount();

    for (uint v = 0; v < vertexCount; v++)
    {
        const HalfEdge::Vertex * vertex = mesh->vertexAt(v);
        if (vertex->isBoundary()) return vertex;
    }

    return NULL;
}


HalfEdge::Mesh * nv::unifyVertices(const HalfEdge::Mesh * inputMesh)
{
    HalfEdge::Mesh * mesh = new HalfEdge::Mesh;
    
    // Only add the first colocal.
    const uint vertexCount = inputMesh->vertexCount();
    for (uint v = 0; v < vertexCount; v++) {
        const HalfEdge::Vertex * vertex = inputMesh->vertexAt(v);
        
        if (vertex->isFirstColocal()) {
            mesh->addVertex(vertex->pos);
        }
    }

    nv::Array<uint> indexArray;

    // Add new faces pointing to first colocals.
    uint faceCount = inputMesh->faceCount();
    for (uint f = 0; f < faceCount; f++) {
        const HalfEdge::Face * face = inputMesh->faceAt(f);

        indexArray.clear();

        for (HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance()) {
            const HalfEdge::Edge * edge = it.current();
            const HalfEdge::Vertex * vertex = edge->vertex->firstColocal();

            indexArray.append(vertex->id);
        }

        mesh->addFace(indexArray);
    }

    mesh->linkBoundary();

    return mesh;
}

#include "nvmath/Basis.h"

static bool pointInTriangle(const Vector2 & p, const Vector2 & a, const Vector2 & b, const Vector2 & c)
{
    return triangleArea(a, b, p) >= 0.00001f && 
        triangleArea(b, c, p) >= 0.00001f && 
        triangleArea(c, a, p) >= 0.00001f; 
}


// This is doing a simple ear-clipping algorithm that skips invalid triangles. Ideally, we should
// also sort the ears by angle, start with the ones that have the smallest angle and proceed in order.
HalfEdge::Mesh * nv::triangulate(const HalfEdge::Mesh * inputMesh)
{
    HalfEdge::Mesh * mesh = new HalfEdge::Mesh;
    
    // Add all vertices.
    const uint vertexCount = inputMesh->vertexCount();
    for (uint v = 0; v < vertexCount; v++) {
        const HalfEdge::Vertex * vertex = inputMesh->vertexAt(v);
        mesh->addVertex(vertex->pos);
    }

    Array<int> polygonVertices;
    Array<float> polygonAngles;
    Array<Vector2> polygonPoints;

    const uint faceCount = inputMesh->faceCount();
    for (uint f = 0; f < faceCount; f++)
    {
        const HalfEdge::Face * face = inputMesh->faceAt(f);
        nvDebugCheck(face != NULL);

        const uint edgeCount = face->edgeCount();
        nvDebugCheck(edgeCount >= 3);

        polygonVertices.clear();
        polygonVertices.reserve(edgeCount);

        if (edgeCount == 3) {
            // Simple case for triangles.
            for (HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
            {
                const HalfEdge::Edge * edge = it.current();
                const HalfEdge::Vertex * vertex = edge->vertex;
                polygonVertices.append(vertex->id);
            }

            int v0 = polygonVertices[0];
            int v1 = polygonVertices[1];
            int v2 = polygonVertices[2];

            mesh->addFace(v0, v1, v2);
        }
        else {
            // Build 2D polygon projecting vertices onto normal plane.
            // Faces are not necesarily planar, this is for example the case, when the face comes from filling a hole. In such cases
            // it's much better to use the best fit plane.
            const Vector3 fn = face->normal();

            Basis basis;
            basis.buildFrameForDirection(fn);

            polygonPoints.clear();
            polygonPoints.reserve(edgeCount);
            polygonAngles.clear();
            polygonAngles.reserve(edgeCount);

            for (HalfEdge::Face::ConstEdgeIterator it(face->edges()); !it.isDone(); it.advance())
            {
                const HalfEdge::Edge * edge = it.current();
                const HalfEdge::Vertex * vertex = edge->vertex;
                polygonVertices.append(vertex->id);
                
                Vector2 p;
                p.x = dot(basis.tangent, vertex->pos);
                p.y = dot(basis.bitangent, vertex->pos);

                polygonPoints.append(p);
            }
            polygonAngles.resize(edgeCount);

            while (polygonVertices.size() > 2) {
                uint size = polygonVertices.size();

                // Update polygon angles. @@ Update only those that have changed.
                float minAngle = 2 * PI;
                uint bestEar = 0; // Use first one if none of them is valid.
                bool bestIsValid = false;
                for (uint i = 0; i < size; i++) {
                    uint i0 = i; 
                    uint i1 = (i+1) % size; // Use Sean's polygon interation trick.
                    uint i2 = (i+2) % size;

                    Vector2 p0 = polygonPoints[i0];
                    Vector2 p1 = polygonPoints[i1];
                    Vector2 p2 = polygonPoints[i2];

                    float d = clamp(dot(p0-p1, p2-p1) / (length(p0-p1) * length(p2-p1)), -1.0f, 1.0f);
                    float angle = acosf(d);
                    
                    float area = triangleArea(p0, p1, p2);
                    if (area < 0.0f) angle = 2.0f * PI - angle;

                    polygonAngles[i1] = angle;

                    if (angle < minAngle || !bestIsValid) {

                        // Make sure this is a valid ear, if not, skip this point.
                        bool valid = true;
                        for (uint j = 0; j < size; j++) {
                            if (j == i0 || j == i1 || j == i2) continue;
                            Vector2 p = polygonPoints[j];

                            if (pointInTriangle(p, p0, p1, p2)) {
                                valid = false;
                                break;
                            }
                        }

                        if (valid || !bestIsValid) {
                            minAngle = angle;
                            bestEar = i1;
                            bestIsValid = valid;
                        }
                    }
                }

                nvDebugCheck(minAngle <= 2 * PI);

                // Clip best ear:

                uint i0 = (bestEar+size-1) % size;
                uint i1 = (bestEar+0) % size;
                uint i2 = (bestEar+1) % size;

                int v0 = polygonVertices[i0];
                int v1 = polygonVertices[i1];
                int v2 = polygonVertices[i2];
                
                mesh->addFace(v0, v1, v2);

                polygonVertices.removeAt(i1);
                polygonPoints.removeAt(i1);
                polygonAngles.removeAt(i1);
            }
        }

#if 0

        uint i = 0;
        while (polygonVertices.size() > 2 && i < polygonVertices.size()) {
            uint size = polygonVertices.size();
            uint i0 = (i+0) % size;
            uint i1 = (i+1) % size;
            uint i2 = (i+2) % size;

            const HalfEdge::Vertex * v0 = polygonVertices[i0];
            const HalfEdge::Vertex * v1 = polygonVertices[i1];
            const HalfEdge::Vertex * v2 = polygonVertices[i2];

            const Vector3 p0 = v0->pos;
            const Vector3 p1 = v1->pos;
            const Vector3 p2 = v2->pos;

            const Vector3 e0 = p2 - p1;
            const Vector3 e1 = p0 - p1;

            // If this ear forms a valid triangle, setup relations, remove v1 and repeat.
            Vector3 n = cross(e0, e1);
            float len = dot(fn, n); // = sin(angle)
            
            float angle = asin(len);


            if (len > 0.0f) {
                mesh->addFace(v0->id(), v1->id(), v2->id());
                polygonVertices.removeAt(i1);
                polygonAngles.removeAt(i1);
                if (i2 > i1) i2--;
                // @@ Update angles at i0 and i2
            }
            else {
                i++;
            }
        }

        // @@ Create a few degenerate triangles to avoid introducing holes.
        i = 0;
        const uint size = polygonVertices.size();
        while (i < size - 2) {
            uint i0 = (i+0) % size;
            uint i1 = (i+1) % size;
            uint i2 = (i+2) % size;

            const HalfEdge::Vertex * v0 = polygonVertices[i0];
            const HalfEdge::Vertex * v1 = polygonVertices[i1];
            const HalfEdge::Vertex * v2 = polygonVertices[i2];

            mesh->addFace(v0->id(), v1->id(), v2->id());
            i++;
        }
#endif
    }

    mesh->linkBoundary();

    return mesh;
}