imstkCellMesh.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.
*/

#include "imstkAbstractCellMesh.h"

#pragma once

namespace imstk
{
template<int N>
class CellMesh : public AbstractCellMesh
{
public:
    static constexpr int CellVertexCount = N;
    using VertexDataType = VecDataArray<double, 3>;
    using CellIndexType  = VecDataArray<int, N>;
    using CellType       = Eigen::Matrix<int, N, 1>;

    CellMesh() : m_indices(std::make_shared<VecDataArray<int, N>>()) { }
    ~CellMesh() override = default;

    void initialize(std::shared_ptr<VecDataArray<double, 3>> vertices,
                    std::shared_ptr<VecDataArray<int, N>> indices)
    {
        clear();

        PointSet::initialize(vertices);
        setCells(indices);
    }

    int getCellVertexCount() const override { return CellVertexCount; }

    void clear() override
    {
        AbstractCellMesh::clear();
        if (m_indices != nullptr)
        {
            m_indices->clear();
        }
    }

    void computeVertexToCellMap() override
    {
        m_vertexToCells.clear();
        m_vertexToCells.resize(m_vertexPositions->size());

        int cellId = 0;
        for (const auto& cell : *m_indices)
        {
            // \todo: Could variadic unfold
            // Subclasses can implement a more efficient version if needbe
            for (int i = 0; i < N; i++)
            {
                m_vertexToCells.at(cell[i]).insert(cellId);
            }
            cellId++;
        }
    }

    void computeVertexNeighbors() override
    {
        m_vertexToNeighborVertex.clear();
        m_vertexToNeighborVertex.resize(m_vertexPositions->size());
        this->computeVertexToCellMap();

        // For every vertex
        const VecDataArray<int, N>& indices = *m_indices;
        for (size_t vertexId = 0; vertexId < m_vertexToNeighborVertex.size(); vertexId++)
        {
            // For every cell it is connected too
            for (const int cellId : m_vertexToCells.at(vertexId))
            {
                // For every vertex of that cell
                for (int i = 0; i < N; i++)
                {
                    // So long as its not the source vertex (not a neighbor of itself)
                    const int vertexId2 = indices[cellId][i];
                    if (vertexId2 != static_cast<int>(vertexId))
                    {
                        m_vertexToNeighborVertex.at(vertexId).insert(vertexId2);
                    }
                }
            }
        }
    }

    virtual Eigen::Vector<double, N> computeBarycentricWeights(const int    imstkNotUsed(cellId),
                                                               const Vec3d& imstkNotUsed(pos)) const
    {
        return Eigen::Vector<double, N>::Zero();
    }

    Vec3d computeWorldPosition(const int cellId,
                               const Eigen::Matrix<double, N, 1>& bary) const
    {
        Vec3d position = Vec3d::Zero();

        const VecDataArray<double, 3>& vertices = *m_vertexPositions;
        const VecDataArray<int, N>&    indices  = *m_indices;

        const Eigen::Matrix<int, N, 1>& cell = indices[cellId];

        for (int i = 0; i < N; i++)
        {
            position += vertices[cell[i]] * bary[i];
        }
        return position;
    }

    std::shared_ptr<AbstractDataArray> getAbstractCells() const override { return m_indices; }

    void setCells(std::shared_ptr<VecDataArray<int, N>> indices) { m_indices = indices; }
    std::shared_ptr<VecDataArray<int, N>> getCells() const { return m_indices; }

    int getNumCells() const override { return m_indices->size(); }

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

protected:
    std::shared_ptr<VecDataArray<int, N>> m_indices = nullptr;

private:
    CellMesh<N>* cloneImplementation() const
    {
        // Do shallow copy
        CellMesh<N>* geom = new CellMesh<N>(*this);
        // Deal with deep copy members
        geom->m_indices = std::make_shared<VecDataArray<int, N>>(*m_indices);
        for (auto i : m_cellAttributes)
        {
            geom->m_cellAttributes[i.first] = i.second->clone();
        }
        geom->m_initialVertexPositions = std::make_shared<VecDataArray<double, 3>>(*m_initialVertexPositions);
        geom->m_vertexPositions = std::make_shared<VecDataArray<double, 3>>(*m_vertexPositions);
        for (auto i : m_vertexAttributes)
        {
            geom->m_vertexAttributes[i.first] = i.second->clone();
        }
        return geom;
    }
};
} // namespace imstk