imstkSurfaceMesh.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkCellMesh.h"
#include "imstkMacros.h"

#include <array>
#include <unordered_set>

namespace imstk
{
struct NormalGroup
{
    Vec3d position;
    Vec3d normal;
};
} // namespace imstk

namespace imstk
{
struct TriCell
{
    std::array<std::uint32_t, 3> vertexIds;

    TriCell(std::uint32_t id0, std::uint32_t id1, std::uint32_t id2)
    {
        vertexIds[0] = id0;
        vertexIds[1] = id1;
        vertexIds[2] = id2;
        if (vertexIds[0] > vertexIds[1])
        {
            std::swap(vertexIds[0], vertexIds[1]);
        }
        if (vertexIds[1] > vertexIds[2])
        {
            std::swap(vertexIds[1], vertexIds[2]);
        }
        if (vertexIds[0] > vertexIds[1])
        {
            std::swap(vertexIds[0], vertexIds[1]);
        }
    }

    // Test true equivalence
    bool operator==(const TriCell& other) const
    {
        // Only works if sorted
        return (vertexIds[0] == other.vertexIds[0] && vertexIds[1] == other.vertexIds[1]
                && vertexIds[2] == other.vertexIds[2]);
    }
};
} // namespace imstk

namespace std
{
template<>
struct hash<imstk::TriCell>
{
    // A 128 int could garuntee no collisions but its harder to find support for
    std::size_t operator()(const imstk::TriCell& k) const
    {
        using std::size_t;
        using std::hash;

        // Assuming sorted
        const std::size_t r =
            imstk::symCantor(static_cast<size_t>(k.vertexIds[0]), static_cast<size_t>(k.vertexIds[1]));
        return imstk::symCantor(r, static_cast<size_t>(k.vertexIds[2]));
    }
};
template<> struct less<imstk::NormalGroup>
{
    bool operator()(const imstk::NormalGroup& group1,
                    const imstk::NormalGroup& group2) const
    {
        if (group1.position != group2.position)
        {
            return (group1.position.x() < group2.position.x());
        }

        if (group1.normal != group2.normal)
        {
            return (group1.normal.x() < group2.normal.x());
        }

        return false;
    }
};
} // namespace std

namespace imstk
{
class SurfaceMesh : public CellMesh<3>
{
public:
    SurfaceMesh() = default;
    ~SurfaceMesh() override = default;

    IMSTK_TYPE_NAME(SurfaceMesh)

    
    void initialize(std::shared_ptr<VecDataArray<double, 3>> vertices,
                    std::shared_ptr<VecDataArray<int, 3>> triangleIndices,
                    const bool computeDerivedData = false);

    void initialize(std::shared_ptr<VecDataArray<double, 3>> vertices,
                    std::shared_ptr<VecDataArray<int, 3>> triangleIndices,
                    std::shared_ptr<VecDataArray<double, 3>> normals,
                    const bool computeDerivedData = false);

    void computeTrianglesNormals();

    void computeTriangleTangents();

    void computeVertexNormals();

    void computeVertexTangents();

    Vec3d computeBarycentricWeights(const int tetId, const Vec3d& pos) const override;

    void optimizeForDataLocality();

    void flipNormals();

    void correctWindingOrder();

    void computeUVSeamVertexGroups();

    double getVolume() override;

    int getNumTriangles() const { return getNumCells(); }
    void setTriangleIndices(std::shared_ptr<VecDataArray<int, 3>> indices) { setCells(indices); }
    std::shared_ptr<VecDataArray<int, 3>> getTriangleIndices() const { return getCells(); }

    std::unique_ptr<SurfaceMesh> clone()
    {
        return std::unique_ptr<SurfaceMesh>(cloneImplementation());
    }

protected:
    std::map<NormalGroup, std::shared_ptr<std::vector<size_t>>> m_UVSeamVertexGroups;

private:
    SurfaceMesh* cloneImplementation() const;
};
} // namespace imstk