PolygonWithHoles2d.h

// PolygonWithHoles2d.h:
// ---------------------
//

#ifndef __IPSDKGEOMETRY_POLYGONWITHHOLES2D_H__
#define __IPSDKGEOMETRY_POLYGONWITHHOLES2D_H__

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

#include <IPSDKGeometry/Entity/2d/BaseTypedGeometryEntity2d.h>
#include <IPSDKGeometry/Entity/2d/Polygon/Polygon2d.h>
#include <IPSDKGeometry/Entity/2d/PolygonWithHoles/PolygonWithHoles2dOperators.h>
#include <IPSDKBaseData/Neighborhood/Neighborhood2dTypes.h>
#include <IPSDKUtil/Tools/ForceInline.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 PolygonWithHoles2d : public BaseTypedGeometryEntity2d<T>,
                                             public boost::enable_shared_from_this<PolygonWithHoles2d<T> >
{
    // declare 2d geometry entity
    IPSDK_DECLARE_GEOMETRY_ENTITY_2D(IPSDKGeometry, PolygonWithHoles2d)

// predefined public types
public:
    static const eCoordinateSystem2dType::domain g_coordinateSystem2dType = eCoordinateSystem2dType::eCS2DT_Cartesian;

    static const eEntity2dType::domain g_entity2dType = eEntity2dType::eE2DT_PolygonWithHoles;

    typedef Polygon2d<T> PolygonType;

    typedef PolygonWithHoles2d<T> PolygonWithHolesType;

    typedef boost::shared_ptr<PolygonWithHolesType> PolygonWithHolesPtr;

    typedef boost::shared_ptr<const PolygonWithHolesType> PolygonWithHolesConstPtr;

    typedef boost::weak_ptr<const PolygonWithHolesType> PolygonWithHolesConstWeakPtr;

    typedef std::vector<PolygonWithHolesConstPtr> PolygonConstColl;

    typedef std::vector<PolygonWithHolesPtr> PolygonColl;

    typedef typename PolygonColl::iterator HoleIterator;

public:
    PolygonWithHoles2d();
    ~PolygonWithHoles2d();

// methods
public:
    inline eCoordinateSystem2dType  getCoordinateSystem2dType() const;

    inline eEntity2dType            getEntity2dType() const;

    inline const ePolygon2dType&    getPolygon2dType() const;

    inline PolygonWithHolesConstPtr getParent() const;

    inline void                     setParent(const PolygonWithHolesConstPtr& pParent);

    ipUInt32                        getNbTotPolygons() const;

    ipUInt32                        getNbTotPoints() const;

    inline bool                     isEmpty() const;

    inline ipUInt32                 getNbExteriorPoints() const;

    inline const PolygonType&       getExteriorPolygon() const;

    inline PolygonType&             getExteriorPolygon();

    inline bool                     hasHoles() const;

    inline ipUInt32                 getNbHoles() const;

    inline const PolygonConstColl&  getPolygonHoles() const;

    inline PolygonColl&             getPolygonHoles();

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

    void                            clearPolygonHoles();

    void                            clear();

// attributes
protected:
    PolygonWithHolesConstWeakPtr    _pParent;

    PolygonType                     _exteriorPolygon;

    PolygonColl                     _polygonHoles;
};


template <typename T>
inline eCoordinateSystem2dType
PolygonWithHoles2d<T>::getCoordinateSystem2dType() const
{
    return g_coordinateSystem2dType;
}

template <typename T>
inline eEntity2dType
PolygonWithHoles2d<T>::getEntity2dType() const
{
    return g_entity2dType;
}

template <typename T>
inline const ePolygon2dType&
PolygonWithHoles2d<T>::getPolygon2dType() const
{
    return _exteriorPolygon.getPolygon2dType();
}

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

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

template <typename T>
IPSDK_FORCEINLINE const typename PolygonWithHoles2d<T>::PolygonType&
PolygonWithHoles2d<T>::getExteriorPolygon() const
{
    return _exteriorPolygon;
}

template <typename T>
IPSDK_FORCEINLINE typename PolygonWithHoles2d<T>::PolygonType&
PolygonWithHoles2d<T>::getExteriorPolygon()
{
    return _exteriorPolygon;
}

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

template <typename T>
IPSDK_FORCEINLINE ipUInt32
PolygonWithHoles2d<T>::getNbExteriorPoints() const
{
    return _exteriorPolygon.getNbPoints();
}

template <typename T>
IPSDK_FORCEINLINE const typename PolygonWithHoles2d<T>::PolygonConstColl&
PolygonWithHoles2d<T>::getPolygonHoles() const
{
    return reinterpret_cast<const PolygonConstColl&>(_polygonHoles);
}

template <typename T>
IPSDK_FORCEINLINE typename PolygonWithHoles2d<T>::PolygonColl&
PolygonWithHoles2d<T>::getPolygonHoles()
{
    return _polygonHoles;
}

template <typename T>
IPSDK_FORCEINLINE bool
PolygonWithHoles2d<T>::hasHoles() const
{
    if (_polygonHoles.empty() == true)
        return false;
    else
        return true;
}

template <typename T>
IPSDK_FORCEINLINE ipUInt32
PolygonWithHoles2d<T>::getNbHoles() const
{
    return static_cast<ipUInt32>(_polygonHoles.size());
}

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

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


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

#pragma warning (pop)

#endif // __IPSDKGEOMETRY_POLYGONWITHHOLES2D_H__