TriangleMesh.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_DATASTRUCTURES_TRIANGLEMESH_H
#define SURGSIM_DATASTRUCTURES_TRIANGLEMESH_H

#include <array>
#include <memory>

#include "SurgSim/DataStructures/EmptyData.h"
#include "SurgSim/DataStructures/MeshElement.h"
#include "SurgSim/DataStructures/NormalData.h"
#include "SurgSim/DataStructures/TriangleMeshPlyReaderDelegate.h"
#include "SurgSim/DataStructures/Vertices.h"
#include "SurgSim/Framework/Asset.h"

namespace SurgSim
{
namespace DataStructures
{

template <class VertexData, class EdgeData, class TriangleData>
class TriangleMesh : public Vertices<VertexData>, public SurgSim::Framework::Asset,
    public std::enable_shared_from_this<TriangleMesh<VertexData, EdgeData, TriangleData>>
{
public:
    typedef MeshElement<2, EdgeData> EdgeType;
    typedef MeshElement<3, TriangleData> TriangleType;

    TriangleMesh();

    TriangleMesh(const TriangleMesh<VertexData, EdgeData, TriangleData>& other);

    template <class V, class E, class T>
    explicit TriangleMesh(const TriangleMesh<V, E, T>& other);

    virtual ~TriangleMesh();

    TriangleMesh(TriangleMesh&& other);

    TriangleMesh<VertexData, EdgeData, TriangleData>& operator=(
        const TriangleMesh<VertexData, EdgeData, TriangleData>& other);

    TriangleMesh<VertexData, EdgeData, TriangleData>& operator=(
        TriangleMesh<VertexData, EdgeData, TriangleData>&& other);


    std::string getClassName() const override;

    size_t addEdge(const EdgeType& edge);

    size_t addTriangle(const TriangleType& triangle);

    size_t getNumEdges() const;

    size_t getNumTriangles() const;

    const std::vector<EdgeType>& getEdges() const;

    std::vector<EdgeType>& getEdges();

    const std::vector<TriangleType>& getTriangles() const;

    std::vector<TriangleType>& getTriangles();

    const EdgeType& getEdge(size_t id) const;

    EdgeType& getEdge(size_t id);

    std::array<SurgSim::Math::Vector3d, 2> getEdgePositions(size_t id) const;

    const TriangleType& getTriangle(size_t id) const;

    TriangleType& getTriangle(size_t id);

    void removeTriangle(size_t id);

    std::array<SurgSim::Math::Vector3d, 3> getTrianglePositions(size_t id) const;

    bool isValid() const;

    void save(const std::string& fileName);

protected:
    virtual void doClearEdges();

    virtual void doClearTriangles();

    virtual bool isEqual(const Vertices<VertexData>& mesh) const;

    bool doLoad(const std::string& fileName) override;

    using Vertices<VertexData>::doClearVertices;

    static std::string m_className;

private:

    virtual void doClear();

    std::vector<EdgeType> m_edges;

    std::vector<TriangleType> m_triangles;

    std::vector<size_t> m_freeTriangles;

public:
    // Dependent name resolution for inherited functions and typenames from templates
    using typename Vertices<VertexData>::VertexType;
    using Vertices<VertexData>::addVertex;
    using Vertices<VertexData>::getNumVertices;
    using Vertices<VertexData>::getVertices;

};

typedef TriangleMesh<EmptyData, EmptyData, EmptyData> TriangleMeshPlain;

};  // namespace DataStructures
};  // namespace SurgSim

#include "SurgSim/DataStructures/TriangleMesh-inl.h"

#endif  // SURGSIM_DATASTRUCTURES_TRIANGLEMESH_H