Mesh3d.h

// Mesh3d.h:
// ---------
//

#ifndef __IPSDKGEOMETRY_MESH3D_H__
#define __IPSDKGEOMETRY_MESH3D_H__

// suppression warnings
// warning C4251: 'ipsdk::geom::Mesh3d<T>::_mesh3dType': class 'ipsdk::geom::eMesh3dType' needs to have dll-interface to be used by clients of class 'ipsdk::geom::Mesh3d<T>'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3dTypes.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3dOperators.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3dFunctions.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Iterators/Mesh3dIterators.h>
#include <IPSDKGeometry/Entity/3d/Triangle/Triangle3d.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <boost/tuple/tuple.hpp>
#include <IPSDKGeometry/Entity/3d/BoundingBox/BoundingBox3d.h>
#include <IPSDKGeometry/Transform/3d/BaseGeometryTransform3d.h>


namespace ipsdk {
namespace geom {
    


template <typename T>
class IPSDKGEOMETRY_API Mesh3d : public BaseTypedGeometryEntity3d<T>
{
    // declare serial class
    IPSDK_DECLARE_GEOMETRY_ENTITY_3D(IPSDKGeometry, Mesh3d)

protected:


// predefined public types
public:
    static const eCoordinateSystem3dType::domain g_coordinateSystem3dType = eCoordinateSystem3dType::eCS3DT_Cartesian;

    static const eEntity3dType::domain g_entity3dType = eEntity3dType::eE3DT_Mesh;

    typedef T DataType;

    typedef Point3dData<T> VertexType;

    typedef std::vector<VertexType> VertexColl;

    typedef typename VertexColl::iterator VertexIterator;

    typedef boost::shared_ptr<BoundingBox3d<DataType>> BoundingBox3dPtr;
    

public:
    Mesh3d();
    ~Mesh3d();

// methods
public:
    inline eCoordinateSystem3dType      getCoordinateSystem3dType() const;

    inline eEntity3dType                getEntity3dType() const;
    
    inline const eMesh3dType&           getMesh3dType() const;

    inline void                         setMesh3dType(const eMesh3dType& mesh3dType);

    inline bool                         isEmpty() const;

    inline ipUInt64                     getNbVertices() const;

    inline ipUInt64                     getNbTriangles() const;

    inline ipUInt64                     getNbEdges() const;

    inline const VertexColl&            getVertexColl() const;

    inline VertexColl&                  getVertexColl();

    inline const UInt64Vector&          getVertexToHalfEdgeColl() const;

    inline UInt64Vector&                getVertexToHalfEdgeColl();

    inline const UInt64Vector&          getTriangleToHalfEdgeColl() const;

    inline UInt64Vector&                getTriangleToHalfEdgeColl();

    inline const TriVertexIxColl&       getTriVertexIxColl() const;

    inline TriVertexIxColl&             getTriVertexIxColl();


    //inline std::vector<std::vector<ipUInt32>>& getTriVertexIxList();

    inline const Mesh3dHalfEdgeColl&    getHalfEdgeColl() const;

    inline Mesh3dHalfEdgeColl&          getHalfEdgeColl();

    const Mesh3dHalfEdge&               getOppositeHalfEdge(const Mesh3dHalfEdge& halfEdge) const;

    const Mesh3dHalfEdge&               getPreviousHalfEdge(const Mesh3dHalfEdge& halfEdge) const;

    const Mesh3dHalfEdge&               getNextHalfEdge(const Mesh3dHalfEdge& halfEdge) const;

    const VertexType&                   getStartVertex(const Mesh3dHalfEdge& halfEdge) const;

    const VertexType&                   getEndVertex(const Mesh3dHalfEdge& halfEdge) const;

    Triangle3d<T>                       extractTriangle(const ipUInt64 triangleIdx) const;

    Triangle3d<T>                       extractLeftTriangle(const Mesh3dHalfEdge& halfEdge) const;

    Triangle3d<T>                       extractRightTriangle(const Mesh3dHalfEdge& halfEdge) const;

    inline BoundingBox3dPtr             getBoundingBox();

    BoundingBox3dPtr                    computeBoundingBox();

    void                                copyFromMesh(const Mesh3d<T>& meshIn);


    inline VertexIterator               beginVertex();
    inline VertexIterator               endVertex();

    void                                clear();

// attributes
protected:
    eMesh3dType         _mesh3dType;

    VertexColl          _vertexColl;

    UInt64Vector        _vertexToHalfEdgeColl;

    UInt64Vector        _triangleToHalfEdgeColl;

    Mesh3dHalfEdgeColl  _halfEdgeColl;

    TriVertexIxColl     _triVertexIxColl;

    BoundingBox3dPtr    _boundingBox3d;

};


template <typename T>
inline eCoordinateSystem3dType
Mesh3d<T>::getCoordinateSystem3dType() const
{
    return g_coordinateSystem3dType;
}

template <typename T>
inline eEntity3dType
Mesh3d<T>::getEntity3dType() const
{
    return g_entity3dType;
}

template <typename T>
inline const eMesh3dType&
Mesh3d<T>::getMesh3dType() const
{
    return _mesh3dType;
}

template <typename T>
inline void
Mesh3d<T>::setMesh3dType(const eMesh3dType& mesh3dType)
{
    _mesh3dType = mesh3dType;
}

template <typename T>
inline bool
Mesh3d<T>::isEmpty() const
{
    return _vertexColl.empty();
}

template <typename T>
IPSDK_FORCEINLINE ipUInt64
Mesh3d<T>::getNbVertices() const
{
    return static_cast<ipUInt64>(_vertexColl.size());
}

template <typename T>
IPSDK_FORCEINLINE ipUInt64
Mesh3d<T>::getNbTriangles() const
{
    return static_cast<ipUInt64>(_triangleToHalfEdgeColl.size());
}

template <typename T>
IPSDK_FORCEINLINE ipUInt64
Mesh3d<T>::getNbEdges() const
{
    return static_cast<ipUInt64>(_halfEdgeColl.size() / 2);
}

template <typename T>
IPSDK_FORCEINLINE const typename Mesh3d<T>::VertexColl&
Mesh3d<T>::getVertexColl() const
{
    return _vertexColl;
}

template <typename T>
IPSDK_FORCEINLINE typename Mesh3d<T>::VertexColl&
Mesh3d<T>::getVertexColl()
{
    return _vertexColl;
}

template <typename T>
IPSDK_FORCEINLINE const UInt64Vector&
Mesh3d<T>::getVertexToHalfEdgeColl() const
{
    return _vertexToHalfEdgeColl;
}

template <typename T>
IPSDK_FORCEINLINE UInt64Vector&
Mesh3d<T>::getVertexToHalfEdgeColl()
{
    return _vertexToHalfEdgeColl;
}

template <typename T>
IPSDK_FORCEINLINE const UInt64Vector&
Mesh3d<T>::getTriangleToHalfEdgeColl() const
{
    return _triangleToHalfEdgeColl;
}

template <typename T>
IPSDK_FORCEINLINE UInt64Vector&
Mesh3d<T>::getTriangleToHalfEdgeColl()
{
    return _triangleToHalfEdgeColl;
}

template <typename T>
//TEST//
IPSDK_FORCEINLINE const TriVertexIxColl&
Mesh3d<T>::getTriVertexIxColl() const
{
    return _triVertexIxColl;
}

template <typename T>
//TEST//
IPSDK_FORCEINLINE TriVertexIxColl&
Mesh3d<T>::getTriVertexIxColl()
{
    return _triVertexIxColl;
}
/*
template <typename T>
IPSDK_FORCEINLINE std::vector<std::vector<ipUInt32>>&
Mesh3d<T>::getTriVertexIxList()
{
    typedef std::vector<std::vector<ipUInt32>> TriVertexIxListType;
    TriVertexIxListType triVertexIxList;
    triVertexIxList.resize(_triVertexIxColl.size());

    TriVertexIxListType::iterator it = triVertexIxList.begin();
    for (TriVertexIx& curTriVertexIx:  _triVertexIxColl) {

        (*it).resize(3);

        std::vector<ipUInt32>::iterator subIt = it->begin();

        (*subIt++) = curTriVertexIx._vertexIx0;
        (*subIt++) = curTriVertexIx._vertexIx1;
        (*subIt++) = curTriVertexIx._vertexIx2;

        ++it;
    }

    return triVertexIxList;
}
*/


template <typename T>
IPSDK_FORCEINLINE const Mesh3dHalfEdgeColl&
Mesh3d<T>::getHalfEdgeColl() const
{
    return _halfEdgeColl;
}

template <typename T>
IPSDK_FORCEINLINE Mesh3dHalfEdgeColl&
Mesh3d<T>::getHalfEdgeColl()
{
    return _halfEdgeColl;
}

template <typename T>
IPSDK_FORCEINLINE typename Mesh3d<T>::VertexIterator
Mesh3d<T>::beginVertex()
{
    return _vertexColl.begin();
}

template <typename T>
IPSDK_FORCEINLINE typename Mesh3d<T>::VertexIterator
Mesh3d<T>::endVertex()
{
    return _vertexColl.end();
}

template <typename T>
IPSDK_FORCEINLINE typename Mesh3d<T>::BoundingBox3dPtr
Mesh3d<T>::getBoundingBox()
{
    if (_boundingBox3d.get() == nullptr)
        _boundingBox3d = computeBoundingBox();
    
    return _boundingBox3d;
}



} // end of namespace geom
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_MESH3D_H__