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_ */