nh-rep/code/pre_processing/ParametricSample/Mathematics/MeshCurvature.h

// David Eberly, Geometric Tools, Redmond WA 98052
// Copyright (c) 1998-2021
// Distributed under the Boost Software License, Version 1.0.
// https://www.boost.org/LICENSE_1_0.txt
// https://www.geometrictools.com/License/Boost/LICENSE_1_0.txt
// Version: 4.0.2019.08.13

#pragma once

#include <Mathematics/Matrix2x2.h>
#include <Mathematics/Matrix3x3.h>

// The MeshCurvature class estimates principal curvatures and principal
// directions at the vertices of a manifold triangle mesh.  The algorithm
// is described in
// https://www.geometrictools.com/Documentation/MeshDifferentialGeometry.pdf

namespace gte
{
    template <typename Real>
    class MeshCurvature
    {
    public:
        MeshCurvature() = default;

        // The input to operator() is a triangle mesh with the specified
        // vertex buffer and index buffer.  The number of elements of
        // 'indices' must be a multiple of 3, each triple of indices
        // (3*t, 3*t+1, 3*t+2) representing the triangle with vertices
        // (vertices[3*t], vertices[3*t+1], vertices[3*t+2]).  The
        // singularity threshold is a small nonnegative number.  It is
        // used to characterize whether the DWTrn matrix is singular.  In
        // theory, set the threshold to zero.  In practice you might have
        // to set this to a small positive number.

        void operator()(
            size_t numVertices, Vector3<Real> const* vertices,
            size_t numTriangles, unsigned int const* indices,
            Real singularityThreshold)
        {
            mNormals.resize(numVertices);
            mMinCurvatures.resize(numVertices);
            mMaxCurvatures.resize(numVertices);
            mMinDirections.resize(numVertices);
            mMaxDirections.resize(numVertices);

            // Compute the normal vectors for the vertices as an
            // area-weighted sum of the triangles sharing a vertex.
            Vector3<Real> vzero{ (Real)0, (Real)0, (Real)0 };
            std::fill(mNormals.begin(), mNormals.end(), vzero);
            unsigned int const* currentIndex = indices;
            for (size_t i = 0; i < numTriangles; ++i)
            {
                // Get vertex indices.
                unsigned int v0 = *currentIndex++;
                unsigned int v1 = *currentIndex++;
                unsigned int v2 = *currentIndex++;

                // Compute the normal (length provides a weighted sum).
                Vector3<Real> edge1 = vertices[v1] - vertices[v0];
                Vector3<Real> edge2 = vertices[v2] - vertices[v0];
                Vector3<Real> normal = Cross(edge1, edge2);

                mNormals[v0] += normal;
                mNormals[v1] += normal;
                mNormals[v2] += normal;
            }
            for (size_t i = 0; i < numVertices; ++i)
            {
                Normalize(mNormals[i]);
            }

            // Compute the matrix of normal derivatives.
            Matrix3x3<Real> mzero;
            std::vector<Matrix3x3<Real>> DNormal(numVertices, mzero);
            std::vector<Matrix3x3<Real>> WWTrn(numVertices, mzero);
            std::vector<Matrix3x3<Real>> DWTrn(numVertices, mzero);
            std::vector<bool> DWTrnZero(numVertices, false);

            currentIndex = indices;
            for (size_t i = 0; i < numTriangles; ++i)
            {
                // Get vertex indices.
                unsigned int v[3];
                v[0] = *currentIndex++;
                v[1] = *currentIndex++;
                v[2] = *currentIndex++;

                for (size_t j = 0; j < 3; j++)
                {
                    unsigned int v0 = v[j];
                    unsigned int v1 = v[(j + 1) % 3];
                    unsigned int v2 = v[(j + 2) % 3];

                    // Compute the edge direction from vertex v0 to vertex v1,
                    // project it to the tangent plane of vertex v0 and
                    // compute the difference of adjacent normals.
                    Vector3<Real> E = vertices[v1] - vertices[v0];
                    Vector3<Real> W = E - Dot(E, mNormals[v0]) * mNormals[v0];
                    Vector3<Real> D = mNormals[v1] - mNormals[v0];
                    for (int row = 0; row < 3; ++row)
                    {
                        for (int col = 0; col < 3; ++col)
                        {
                            WWTrn[v0](row, col) += W[row] * W[col];
                            DWTrn[v0](row, col) += D[row] * W[col];
                        }
                    }

                    // Compute the edge direction from vertex v0 to vertex v2,
                    // project it to the tangent plane of vertex v0 and
                    // compute the difference of adjacent normals.
                    E = vertices[v2] - vertices[v0];
                    W = E - Dot(E, mNormals[v0]) * mNormals[v0];
                    D = mNormals[v2] - mNormals[v0];
                    for (int row = 0; row < 3; ++row)
                    {
                        for (int col = 0; col < 3; ++col)
                        {
                            WWTrn[v0](row, col) += W[row] * W[col];
                            DWTrn[v0](row, col) += D[row] * W[col];
                        }
                    }
                }
            }

            // Add in N*N^T to W*W^T for numerical stability.  In theory 0*0^T
            // is added to D*W^T, but of course no update is needed in the
            // implementation.  Compute the matrix of normal derivatives.
            for (size_t i = 0; i < numVertices; ++i)
            {
                for (int row = 0; row < 3; ++row)
                {
                    for (int col = 0; col < 3; ++col)
                    {
                        WWTrn[i](row, col) = (Real)0.5 * WWTrn[i](row, col) +
                            mNormals[i][row] * mNormals[i][col];
                        DWTrn[i](row, col) *= (Real)0.5;
                    }
                }

                // Compute the max-abs entry of D*W^T.  If this entry is
                // (nearly) zero, flag the DNormal matrix as singular.
                Real maxAbs = (Real)0;
                for (int row = 0; row < 3; ++row)
                {
                    for (int col = 0; col < 3; ++col)
                    {
                        Real absEntry = std::fabs(DWTrn[i](row, col));
                        if (absEntry > maxAbs)
                        {
                            maxAbs = absEntry;
                        }
                    }
                }
                if (maxAbs < singularityThreshold)
                {
                    DWTrnZero[i] = true;
                }

                DNormal[i] = DWTrn[i] * Inverse(WWTrn[i]);
            }

            // If N is a unit-length normal at a vertex, let U and V be
            // unit-length tangents so that {U, V, N} is an orthonormal set.
            // Define the matrix J = [U | V], a 3-by-2 matrix whose columns
            // are U and V.  Define J^T to be the transpose of J, a 2-by-3
            // matrix.  Let dN/dX denote the matrix of first-order derivatives
            // of the normal vector field.  The shape matrix is
            //   S = (J^T * J)^{-1} * J^T * dN/dX * J = J^T * dN/dX * J
            // where the superscript of -1 denotes the inverse; the formula
            // allows for J to be created from non-perpendicular vectors. The
            // matrix S is 2-by-2.  The principal curvatures are the
            // eigenvalues of S.  If k is a principal curvature and W is the
            // 2-by-1 eigenvector corresponding to it, then S*W = k*W (by
            // definition).  The corresponding 3-by-1 tangent vector at the
            // vertex is a principal direction for k and is J*W.
            for (size_t i = 0; i < numVertices; ++i)
            {
                // Compute U and V given N.
                Vector3<Real> basis[3];
                basis[0] = mNormals[i];
                ComputeOrthogonalComplement(1, basis);
                Vector3<Real> const& U = basis[1];
                Vector3<Real> const& V = basis[2];

                if (DWTrnZero[i])
                {
                    // At a locally planar point.
                    mMinCurvatures[i] = (Real)0;
                    mMaxCurvatures[i] = (Real)0;
                    mMinDirections[i] = U;
                    mMaxDirections[i] = V;
                    continue;
                }

                // Compute S = J^T * dN/dX * J.  In theory S is symmetric, but
                // because dN/dX is estimated, we must ensure that the
                // computed S is symmetric.
                Real s00 = Dot(U, DNormal[i] * U);
                Real s01 = Dot(U, DNormal[i] * V);
                Real s10 = Dot(V, DNormal[i] * U);
                Real s11 = Dot(V, DNormal[i] * V);
                Real avr = (Real)0.5 * (s01 + s10);
                Matrix2x2<Real> S{ s00, avr, avr, s11 };

                // Compute the eigenvalues of S (min and max curvatures).
                Real trace = S(0, 0) + S(1, 1);
                Real det = S(0, 0) * S(1, 1) - S(0, 1) * S(1, 0);
                Real discr = trace * trace - (Real)4.0 * det;
                Real rootDiscr = std::sqrt(std::max(discr, (Real)0));
                mMinCurvatures[i] = (Real)0.5* (trace - rootDiscr);
                mMaxCurvatures[i] = (Real)0.5* (trace + rootDiscr);

                // Compute the eigenvectors of S.
                Vector2<Real> W0{ S(0, 1), mMinCurvatures[i] - S(0, 0) };
                Vector2<Real> W1{ mMinCurvatures[i] - S(1, 1), S(1, 0) };
                if (Dot(W0, W0) >= Dot(W1, W1))
                {
                    Normalize(W0);
                    mMinDirections[i] = W0[0] * U + W0[1] * V;
                }
                else
                {
                    Normalize(W1);
                    mMinDirections[i] = W1[0] * U + W1[1] * V;
                }

                W0 = Vector2<Real>{ S(0, 1), mMaxCurvatures[i] - S(0, 0) };
                W1 = Vector2<Real>{ mMaxCurvatures[i] - S(1, 1), S(1, 0) };
                if (Dot(W0, W0) >= Dot(W1, W1))
                {
                    Normalize(W0);
                    mMaxDirections[i] = W0[0] * U + W0[1] * V;
                }
                else
                {
                    Normalize(W1);
                    mMaxDirections[i] = W1[0] * U + W1[1] * V;
                }
            }
        }

        void operator()(
            std::vector<Vector3<Real>> const& vertices,
            std::vector<unsigned int> const& indices,
            Real singularityThreshold)
        {
            operator()(vertices.size(), vertices.data(), indices.size() / 3,
                indices.data(), singularityThreshold);
        }

        inline std::vector<Vector3<Real>> const& GetNormals() const
        {
            return mNormals;
        }

        inline std::vector<Real> const& GetMinCurvatures() const
        {
            return mMinCurvatures;
        }

        inline std::vector<Real> const& GetMaxCurvatures() const
        {
            return mMaxCurvatures;
        }

        inline std::vector<Vector3<Real>> const& GetMinDirections() const
        {
            return mMinDirections;
        }

        inline std::vector<Vector3<Real>> const& GetMaxDirections() const
        {
            return mMaxDirections;
        }

    private:
        std::vector<Vector3<Real>> mNormals;
        std::vector<Real> mMinCurvatures;
        std::vector<Real> mMaxCurvatures;
        std::vector<Vector3<Real>> mMinDirections;
        std::vector<Vector3<Real>> mMaxDirections;
    };
}