BaseMesh.hpp

Go to the documentation of this file.

 
/*
 * BaseMesh.hpp
 *
 *  @date 02.06.2017
 *  @author Lukas Kalbertodt <lukas.kalbertodt@gmail.com>
 */
 
#ifndef LVR2_GEOMETRY_BASEMESH_H_
#define LVR2_GEOMETRY_BASEMESH_H_
 
#include <cstdint>
#include <array>
#include <vector>
#include <type_traits>
#include <memory>
#include <boost/optional.hpp>
 
 
 
#include "Handles.hpp"
 
namespace lvr2
{
 
template<typename HandleT>
class MeshHandleIterator
{
    static_assert(std::is_base_of<BaseHandle<Index>, HandleT>::value, "HandleT must inherit from BaseHandle!");
public:
    virtual MeshHandleIterator& operator++() = 0;
    virtual bool operator==(const MeshHandleIterator& other) const = 0;
    virtual bool operator!=(const MeshHandleIterator& other) const = 0;
 
    virtual HandleT operator*() const = 0;
 
    virtual ~MeshHandleIterator() = default;
 
    using HandleType = HandleT;
};
 
template<typename HandleT>
class MeshHandleIteratorPtr
{
public:
    MeshHandleIteratorPtr(std::unique_ptr<MeshHandleIterator<HandleT>> iter) : m_iter(std::move(iter)) {};
    MeshHandleIteratorPtr& operator++();
    bool operator==(const MeshHandleIteratorPtr& other) const;
    bool operator!=(const MeshHandleIteratorPtr& other) const;
    HandleT operator*() const;
 
    using HandleType = HandleT;
private:
    std::unique_ptr<MeshHandleIterator<HandleT>> m_iter;
};
 
// Forward declaration
template <typename> class FaceIteratorProxy;
template <typename> class EdgeIteratorProxy;
template <typename> class VertexIteratorProxy;
 
struct EdgeCollapseResult;
struct EdgeCollapseRemovedFace;
 
template<typename BaseVecT>
class BaseMesh
{
public:
 
    virtual ~BaseMesh() {}
 
    // =======================================================================
    // Pure virtual methods (need to be implemented)
    // =======================================================================
 
    virtual VertexHandle addVertex(BaseVecT pos) = 0;
 
    virtual FaceHandle addFace(VertexHandle v1, VertexHandle v2, VertexHandle v3) = 0;
 
    virtual void removeFace(FaceHandle handle) = 0;
 
    virtual EdgeCollapseResult collapseEdge(EdgeHandle edgeH) = 0;
 
    virtual void flipEdge(EdgeHandle edgeH) = 0;
 
    virtual size_t numVertices() const = 0;
 
    virtual size_t numFaces() const = 0;
 
    virtual size_t numEdges() const = 0;
 
    virtual bool containsVertex(VertexHandle vH) const = 0;
 
    virtual bool containsFace(FaceHandle vH) const = 0;
 
    virtual bool containsEdge(EdgeHandle vH) const = 0;
 
    virtual Index nextVertexIndex() const = 0;
 
    virtual Index nextFaceIndex() const = 0;
 
    virtual Index nextEdgeIndex() const = 0;
 
    virtual BaseVecT getVertexPosition(VertexHandle handle) const = 0;
 
    virtual BaseVecT& getVertexPosition(VertexHandle handle) = 0;
 
    virtual std::array<VertexHandle, 3> getVerticesOfFace(FaceHandle handle) const = 0;
 
    virtual std::array<EdgeHandle, 3> getEdgesOfFace(FaceHandle handle) const = 0;
 
    virtual void getNeighboursOfFace(FaceHandle handle, std::vector<FaceHandle>& facesOut) const = 0;
 
    virtual std::array<VertexHandle, 2> getVerticesOfEdge(EdgeHandle edgeH) const = 0;
 
    virtual std::array<OptionalFaceHandle, 2> getFacesOfEdge(EdgeHandle edgeH) const = 0;
 
    virtual void getFacesOfVertex(VertexHandle handle, std::vector<FaceHandle>& facesOut) const = 0;
 
    virtual void getEdgesOfVertex(VertexHandle handle, std::vector<EdgeHandle>& edgesOut) const = 0;
 
    virtual void getNeighboursOfVertex(VertexHandle handle, std::vector<VertexHandle>& verticesOut) const = 0;
 
    virtual OptionalFaceHandle getOppositeFace(FaceHandle faceH, VertexHandle vertexH) const = 0;
 
    virtual OptionalEdgeHandle getOppositeEdge(FaceHandle faceH, VertexHandle vertexH) const = 0;
 
    virtual OptionalVertexHandle getOppositeVertex(FaceHandle faceH, EdgeHandle edgeH) const = 0;
 
    virtual MeshHandleIteratorPtr<VertexHandle> verticesBegin() const = 0;
 
    virtual MeshHandleIteratorPtr<VertexHandle> verticesEnd() const = 0;
 
    virtual MeshHandleIteratorPtr<FaceHandle> facesBegin() const = 0;
 
    virtual MeshHandleIteratorPtr<FaceHandle> facesEnd() const = 0;
 
    virtual MeshHandleIteratorPtr<EdgeHandle> edgesBegin() const = 0;
 
    virtual MeshHandleIteratorPtr<EdgeHandle> edgesEnd() const = 0;
 
    // =======================================================================
    // Provided methods (already implemented)
    // =======================================================================
 
    virtual std::array<BaseVecT, 3> getVertexPositionsOfFace(FaceHandle handle) const;
 
    BaseVecT calcFaceCentroid(FaceHandle handle) const;
 
    typename BaseVecT::CoordType calcFaceArea(FaceHandle handle) const;
 
    virtual std::vector<FaceHandle> getNeighboursOfFace(FaceHandle handle) const;
 
    virtual bool isCollapsable(EdgeHandle handle) const;
 
    virtual bool isFlippable(EdgeHandle handle) const;
 
    virtual bool isBorderEdge(EdgeHandle handle) const = 0;
 
    virtual bool isFaceInsertionValid(VertexHandle v1, VertexHandle v2, VertexHandle v3) const;
 
    virtual OptionalFaceHandle getFaceBetween(VertexHandle aH, VertexHandle bH, VertexHandle cH) const;
 
    virtual uint8_t numAdjacentFaces(EdgeHandle handle) const;
 
    virtual std::vector<FaceHandle> getFacesOfVertex(VertexHandle handle) const;
 
    virtual std::vector<EdgeHandle> getEdgesOfVertex(VertexHandle handle) const;
 
    virtual std::vector<VertexHandle> getNeighboursOfVertex(VertexHandle handle) const;
 
    virtual OptionalVertexHandle getVertexBetween(EdgeHandle aH, EdgeHandle bH) const;
 
    virtual OptionalEdgeHandle getEdgeBetween(VertexHandle aH, VertexHandle bH) const;
 
    virtual FaceIteratorProxy<BaseVecT> faces() const;
 
    virtual EdgeIteratorProxy<BaseVecT> edges() const;
 
    virtual VertexIteratorProxy<BaseVecT> vertices() const;
 
};
 
template <typename BaseVecT>
class FaceIteratorProxy
{
public:
    MeshHandleIteratorPtr<FaceHandle> begin() const;
    MeshHandleIteratorPtr<FaceHandle> end() const;
 
    FaceIteratorProxy(const BaseMesh<BaseVecT>& mesh) : m_mesh(mesh) {}
 private:
    const BaseMesh<BaseVecT>& m_mesh;
    friend BaseMesh<BaseVecT>;
};
 
template <typename BaseVecT>
class EdgeIteratorProxy
{
public:
    MeshHandleIteratorPtr<EdgeHandle> begin() const;
    MeshHandleIteratorPtr<EdgeHandle> end() const;
 
    EdgeIteratorProxy(const BaseMesh<BaseVecT>& mesh) : m_mesh(mesh) {}
 private:
    const BaseMesh<BaseVecT>& m_mesh;
    friend BaseMesh<BaseVecT>;
};
 
template <typename BaseVecT>
class VertexIteratorProxy
{
public:
    MeshHandleIteratorPtr<VertexHandle> begin() const;
    MeshHandleIteratorPtr<VertexHandle> end() const;
 
    VertexIteratorProxy(const BaseMesh<BaseVecT>& mesh) : m_mesh(mesh) {}
 private:
    const BaseMesh<BaseVecT>& m_mesh;
    friend BaseMesh<BaseVecT>;
};
 
struct EdgeCollapseRemovedFace
{
    FaceHandle removedFace;
 
    std::array<EdgeHandle, 2> removedEdges;
 
    EdgeHandle newEdge;
 
    EdgeCollapseRemovedFace(
        FaceHandle removedFace,
        std::array<EdgeHandle, 2> removedEdges,
        EdgeHandle newEdge
    ) : removedFace(removedFace), removedEdges(removedEdges), newEdge(newEdge) {};
};
 
struct EdgeCollapseResult
{
    VertexHandle midPoint;
 
    VertexHandle removedPoint;
 
    std::array<boost::optional<EdgeCollapseRemovedFace>, 2> neighbors;
 
    EdgeCollapseResult(VertexHandle midPoint, VertexHandle removedPoint) : midPoint(midPoint), removedPoint(removedPoint) {};
};
 
 
struct VertexSplitResult
{
 
    VertexHandle edgeCenter;
    std::vector<FaceHandle> addedFaces;
 
    VertexSplitResult(VertexHandle longestEdgeCenter) : edgeCenter(longestEdgeCenter) {};
};
 
struct EdgeSplitResult
{
 
    VertexHandle edgeCenter;
    std::vector<FaceHandle> addedFaces;
 
    EdgeSplitResult(VertexHandle longestEdgeCenter) : edgeCenter(longestEdgeCenter) {};
};
 
} // namespace lvr2
 
#include "lvr2/geometry/BaseMesh.tcc"
 
#endif /* LVR2_GEOMETRY_BASEMESH_H_ */