MeshWithHoles3d.h

// MeshWithHoles3d.h:
// ------------------
//

#ifndef __IPSDKGEOMETRY_MESHWITHHOLES3D_H__
#define __IPSDKGEOMETRY_MESHWITHHOLES3D_H__

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

#include <IPSDKGeometry/Entity/3d/BaseTypedGeometryEntity3d.h>
#include <IPSDKGeometry/Entity/3d/Mesh/Mesh3d.h>
#include <IPSDKGeometry/Entity/3d/MeshWithHoles/MeshWithHoles3dOperators.h>
#include <IPSDKGeometry/Entity/3d/MeshWithHoles/MeshWithHoles3dFunctions.h>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <vector>

namespace ipsdk {
namespace geom {


template <typename T>
class IPSDKGEOMETRY_API MeshWithHoles3d : public BaseTypedGeometryEntity3d<T>,
                                          public boost::enable_shared_from_this<MeshWithHoles3d<T> >
{
    // declare 3d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_3D(IPSDKGeometry, MeshWithHoles3d)

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

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

    typedef Mesh3d<T> MeshType;

    typedef MeshWithHoles3d<T> MeshWithHolesType;

    typedef boost::shared_ptr<MeshWithHolesType> MeshWithHolesPtr;

    typedef boost::shared_ptr<const MeshWithHolesType> MeshWithHolesConstPtr;

    typedef boost::weak_ptr<const MeshWithHolesType> MeshWithHolesConstWeakPtr;

    typedef std::vector<MeshWithHolesConstPtr> MeshConstColl;

    typedef std::vector<MeshWithHolesPtr> MeshColl;

    typedef typename MeshColl::iterator HoleIterator;

public:
    MeshWithHoles3d();
    ~MeshWithHoles3d();

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

    inline eEntity3dType            getEntity3dType() const;

    inline const eMesh3dType&       getMesh3dType() const;

    inline MeshWithHolesConstPtr    getParent() const;

    inline void                     setParent(const MeshWithHolesConstPtr& pParent);

    ipUInt64                        getNbTotMesh() const;

    ipUInt64                        getNbTotVertices() const;

    ipUInt64                        getNbTotEdges() const;

    ipUInt64                        getNbTotTriangles() const;

    inline bool                     isEmpty() const;

    ipUInt64                        getNbExteriorVertices() const;

    ipUInt64                        getNbExteriorEdges() const;

    ipUInt64                        getNbExteriorTriangles() const;

    inline const MeshType&          getExteriorMesh() const;

    inline MeshType&                getExteriorMesh();

    inline bool                     hasHoles() const;

    inline ipUInt64                 getNbHoles() const;

    inline const MeshConstColl&     getMeshHoles() const;

    inline MeshColl&                getMeshHoles();

    inline HoleIterator             beginHole();
    inline HoleIterator             endHole();

    void                            clearMeshHoles();

    void                            clear();

// attributes
protected:
    MeshWithHolesConstWeakPtr   _pParent;

    MeshType                    _exteriorMesh;

    MeshColl                    _meshHoles;
};


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

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

template <typename T>
inline const eMesh3dType&
MeshWithHoles3d<T>::getMesh3dType() const
{
    return _exteriorMesh.getMesh3dType();
}

template <typename T>
inline typename MeshWithHoles3d<T>::MeshWithHolesConstPtr
MeshWithHoles3d<T>::getParent() const
{
    return _pParent.lock();
}

template <typename T>
inline void
MeshWithHoles3d<T>::setParent(const MeshWithHolesConstPtr& pParent)
{
    _pParent = pParent;
}

template <typename T>
IPSDK_FORCEINLINE bool
MeshWithHoles3d<T>::isEmpty() const
{
    return _exteriorMesh.isEmpty();
}

//template <typename T>
//IPSDK_FORCEINLINE const typename MeshWithHoles3d<T>::MeshType&
//MeshWithHoles3d<T>::getExteriorMesh() const
//{
//    return _exteriorMesh;
//}
//
//template <typename T>
//IPSDK_FORCEINLINE typename MeshWithHoles3d<T>::MeshType&
//MeshWithHoles3d<T>::getExteriorMesh()
//{
//    return _exteriorMesh;
//}

template <typename T>
IPSDK_FORCEINLINE ipUInt64
MeshWithHoles3d<T>::getNbHoles() const
{
    return static_cast<ipUInt64>(_meshHoles.size());
}

template <typename T>
IPSDK_FORCEINLINE bool
MeshWithHoles3d<T>::hasHoles() const
{
    return _meshHoles.empty() == false;
}

//template <typename T>
//IPSDK_FORCEINLINE const typename MeshWithHoles3d<T>::MeshConstColl&
//MeshWithHoles3d<T>::getMeshHoles() const
//{
//    return reinterpret_cast<const MeshConstColl&>(_meshHoles);
//}
//
//template <typename T>
//IPSDK_FORCEINLINE typename MeshWithHoles3d<T>::MeshColl&
//MeshWithHoles3d<T>::getMeshHoles()
//{
//    return _meshHoles;
//}

template <typename T>
IPSDK_FORCEINLINE typename MeshWithHoles3d<T>::HoleIterator
MeshWithHoles3d<T>::beginHole()
{
    return _meshHoles.begin();
}

template <typename T>
IPSDK_FORCEINLINE typename MeshWithHoles3d<T>::HoleIterator
MeshWithHoles3d<T>::endHole()
{
    return _meshHoles.end();
}


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_MESHWITHHOLES3D_H__