util_topology_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_TOPOLOGY_DTK_HPP_
#define _UTIL_TOPOLOGY_DTK_HPP_
 
 
class Dtk_Coedge;   
class Dtk_Edge; 
class Dtk_Loop;
class Dtk_Face;
class Dtk_Shell; 
class Dtk_Volume; 
class Dtk_Lump; 
class Dtk_Body; 
 
#include "util/util_geom_dtk.hpp"
#include "util/util_topology_ptr_dtk.hpp"
#include <cstdio>
#include "def/define.h"
#include <unordered_map>
 
enum DtkFaceType
{
    DtkFaceType_All,
    DtkFaceType_Bounded,
    DtkFaceType_Wire
};
 
class Dtk_TopologicalEntity : public Dtk_Entity
{
protected:
     enum { _typeID = DTK_TYPE_TOPOLOGICAL_REPRESENTATION_ITEM }; 
 
     Dtk_TopologicalEntity(){}
     virtual ~Dtk_TopologicalEntity();
     friend class Dtk_SmartPtr<Dtk_TopologicalEntity>;
     friend class Dtk_Body;
     virtual void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody) = 0;
    virtual Dtk_Object* Clone() {return NULL;}
     
public:
     virtual Dtk_ID GetTopoID() const;
     virtual Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     virtual Dtk_BodyPtr GetParentBody() const = 0;
     //! \brief Get smart pointer type
     //! \param [in] inId : 
     //! \return  int 
     int DtkDynamicType(const int& inId);
     //! \brief Cast object in vertex
     //! \param [in] inObject : object to cast
     //! \return  static Dtk_Vertex or NULL 
     static Dtk_TopologicalEntity * DtkDynamicCast(Dtk_Object * inObject);
     //! \brief  Return Type of entity
     //! \return  enum type_detk 
     virtual enum type_detk get_type_detk()  const; 
     //! \brief Transform object 
     //! \param [in] inTransfo : matrix to apply 
     //! \return  Dtk_ErrorStatus 
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
};
 
//! \ingroup TOPO
//! \class Dtk_Vertex 
//! \brief Vertex indicates bound of an edge. Vertex has Dtk_Point as geometry value
//!  \SmartPtr{Dtk_VertexPtr}
class Dtk_Vertex:public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_VERTEX }; 
 
     Dtk_Vertex();
     Dtk_Vertex(const Dtk_Vertex &inTopo, Dtk_Body *inParentBody);
 
    virtual ~Dtk_Vertex();
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
     friend class Dtk_SmartPtr<Dtk_Vertex>;
     friend class Dtk_TopologicalEntity;
 
public:
 
     Dtk_ID GetTopoID() const;
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr& inParentBody);
     Dtk_BodyPtr GetParentBody() const;
//! \brief Create a vertex in a body
//! \param [in] inParentBody : parent body
//! \return Dtk_VertexPtr created
    static Dtk_VertexPtr Create(const Dtk_BodyPtr &inParentBody);
//! \brief Get smart pointer type
//! \param [in] inId : 
//! \return  int 
    int DtkDynamicType(const int& inId);
//! \brief Cast object in vertex
//! \param [in] inObject : object to cast
//! \return Casted Dtk_Vertex pointer or NULL 
     static Dtk_Vertex * DtkDynamicCast(Dtk_Object * inObject);
//! \brief  Return Type of entity
//! \return  enum type_detk 
    enum type_detk get_type_detk()  const; 
//! \brief Return Number of Parent Edge
//! \return  Dtk_Size_t 
    Dtk_Size_t GetNumParentEdges() const;
//! \brief Return parent edge at inIndex
//! \param [in] inIndex : index of parent edge 
//! \param [out] outParentEdge : pointer of parent edge
//! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus GetParentEdge(const Dtk_Size_t& inIndex,Dtk_EdgePtr &outParentEdge) const;
//! \brief Add parent Edge
//! \param [in] inParentEdge : pointer of parent edge
//! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus AddParentEdge(const Dtk_EdgePtr& inParentEdge);
//! \brief Add parent Edge
//! \param [in] inParentEdgeId : UUID of parent edge
//! \return  Dtk_ErrorStatus: dtkNoError if OK 
   Dtk_ErrorStatus AddParentEdge(const Dtk_ID &inParentEdgeId);
//! \brief  Return associated geometry 
//! \return  Dtk_PointPtr 
    Dtk_PointPtr GetGeom() const;
//! \brief Set Geometry
//! \param [in] inPoint : Point 
//! \return  void 
    void SetGeom(const Dtk_PointPtr& inPoint);
     //! \brief Get Tolerance 
     //! \deprecated
     //! \return  double Tolerance 
     //! \deprecated Use GetTolerance(Dtk_Double64 &outTolerance) method instead.
     SetAsDeprecated("2022.1", "Use GetTolerance(Dtk_Double64 &outTolerance) method instead.")
     Dtk_Double64 GetTolerance();
 
    //! \brief Get Tolerance 
    //! \param [out] outTolerance : vertex tolerance
    //! \return  dtkNoError if value set or  dtkWarningDefaultValue if default
     Dtk_ErrorStatus GetTolerance(Dtk_Double64 &outTolerance);
 
     //! \brief Set Tolerance 
     //! \param [in] inTol : Tolerance
     void SetTolerance(Dtk_Double64 inTol);
 
     //! \brief Internal Use
     virtual Dtk_ErrorStatus _Store(void*);
     //! \brief Internal Use
     virtual Dtk_Size_t GetSize() const;
};
 
 
//! \ingroup TOPO
//! \class Dtk_Edge 
//! \brief Edge has two vertex for bounds. It has a 3D curve as geometry value
//! \brief Geometrical orientation relative to 3D Curve is always True
//!  \SmartPtr{Dtk_EdgePtr}
class Dtk_Edge:public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_EDGE }; 
 
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
     Dtk_Edge();
     Dtk_Edge(const Dtk_Edge& inEdgeTpCopy, Dtk_Body *inParentBody);
    virtual ~Dtk_Edge();
    friend class Dtk_SmartPtr<Dtk_Edge>;
     friend class Dtk_TopologicalEntity;
 
public:
     Dtk_ID GetTopoID() const;
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
     //! \brief Create an edge in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_EdgePtr created
    static Dtk_EdgePtr Create(const Dtk_BodyPtr &inParentBody);
 
    int DtkDynamicType(const int& inId);
    static Dtk_Edge * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \brief  Get Start Vertex for edge
     //! \param [out] :outVertex start vertex of edge
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetStartVertex(Dtk_VertexPtr &outVertex) const;
     Dtk_ErrorStatus GetStartVertex(Dtk_ID &outVertexId) const;
     //! \brief  Set Start Vertex for edge
     //! \param [in] :inVertex start vertex to set
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus SetStartVertex(const Dtk_VertexPtr& inVertex);
    Dtk_ErrorStatus SetStartVertex(const Dtk_ID& inVertex);
 
     //! \brief  Get End Vertex for edge
     //! \param [out] :outVertex end vertex of edge
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetEndVertex(Dtk_VertexPtr &outVertex) const;
    Dtk_ErrorStatus GetEndVertex(Dtk_ID &outVertexId) const;
 
     //! \brief  Set End Vertex for edge
     //! \param [in] :inVertex end vertex to set
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus SetEndVertex(const Dtk_VertexPtr& inVertex);
    Dtk_ErrorStatus SetEndVertex(const Dtk_ID& inVertex);
 
     //! \brief  Get Number of coedges
     //! \return  Number of coedges
     Dtk_Size_t GetNumCoedges() const ;
 
     //! \brief  Get Corresponding coedges from index
     //! \param [in] :inIndex coedge index
     //! \param [out] :outSecondCoedge coedge pointer
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetParentCoedge(const Dtk_Size_t &inIndex,Dtk_CoedgePtr &outCoedge) const;
    Dtk_ErrorStatus GetParentCoedge(const Dtk_Size_t &inIndex,Dtk_ID &outCoedgeId) const;
 
     //! \brief  Set Corresponding coedges
     //! \param [in] :inFirstCoedge 
     //! \param [in] :inSecondCoedge 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus SetCoedges(const Dtk_CoedgePtr&  inFirstCoedge,const Dtk_CoedgePtr&  inSecondCoedge);
 
     //! \brief  Add a Coedge to Edge
     //! \param [in] :inCoedge 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus AddCoedge(const Dtk_CoedgePtr& inCoedge);
     Dtk_ErrorStatus AddCoedge(const Dtk_ID& inCoedgeId);
 
     //! \brief  Remove a Coedge to Edge's list of coedges
     //! \param [in] :inCoedge 
     void RemoveCoedge(const Dtk_ID &inCoedgeId);
 
 
    enum type_detk get_type_detk()  const;
     
     //! \brief Get edge geometry
     //! \param [in] :inWithVerticesTrim if DTK_TRUE Curve is trimmed with vertices of edge
     //! \return  Dtk_CurvePtr 
    Dtk_CurvePtr GetGeom(Dtk_bool inWithVerticesTrim = DTK_TRUE) const;
     //! \brief Set Geometry
     //! \param [in] inCurve3D : 3D curve supporting the edge 
     //! \return  void 
    void SetGeom(const Dtk_CurvePtr& inCurve3D);
     //! \brief Get Tolerance 
     //! \deprecated Use GetTolerance(Dtk_Double64 &outTolerance) method instead.
     //! \return  double Tolerance 
     SetAsDeprecated("2022.1", "Use GetTolerance(Dtk_Double64 &outTolerance) method instead.")
     Dtk_Double64 GetTolerance();
 
     //! \brief Get Tolerance 
     //! \param [out] outTolerance : edge tolerance
     //! \return  dtkNoError if value set or  dtkWarningDefaultValue if default
     Dtk_ErrorStatus GetTolerance(Dtk_Double64 &outTolerance);
 
     //! \brief Set Tolerance 
     //! \param [in] inTol : Tolerance
     void SetTolerance(Dtk_Double64 inTol);
 
     //! \brief Internal Use
     virtual Dtk_ErrorStatus _Store(void*);
 
     //! \brief Internal Use
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup TOPO
//! \class Dtk_Coedge 
//! \brief Dtk_Coedge is a part of a loop. It's geometry is a UV curve on a surface
//! \brief Orientation is topological orientation relative to Edge
//!  \brief Geometrical orientation relative to UV Curve is always True
//! \SmartPtr{Dtk_CoedgePtr}
class Dtk_Coedge : public Dtk_TopologicalEntity
{
protected:     
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_COEDGE }; 
 
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
     Dtk_Coedge();
     Dtk_Coedge(const Dtk_Coedge& inCoedgeToCopy,Dtk_Body *inParentBody);
    virtual ~Dtk_Coedge();
    friend class Dtk_SmartPtr<Dtk_Coedge>;
     friend class Dtk_TopologicalEntity;
 
public:
     Dtk_ID GetTopoID() const;
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
     //! \brief Create a coedge in a body
     //! \param [in] inParentBody : parent body
     //! \return  Dtk_CoedgePtr created
    static Dtk_CoedgePtr Create(const Dtk_BodyPtr &inParentBody);
 
     //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Coedge * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \brief  Return orientation for coedge relative to Edge
     //! \return  True if coedge and associated Edge  has same sens
     Dtk_bool GetOrientation() const;
     //! \brief  Set orientation for coedge relative to Edge
     //! \param [in] :inOrientation true if coedge and associated Edge has same sens
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus SetOrientation(const Dtk_bool& inOrientation);
 
     //! \brief  Indicates if Coedge is degenerated or not 
     //! \return  DTK_TRUE, DTK_FALSE, or DTK_BOOL_UNKNOWN 
     Dtk_bool IsDegenerated() const;
     //! \brief  Active Degenerated flag for coedge 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus SetDegeneratedFlag();
 
 
     //! \brief Get Edge for coedge 
     //! \param [out] :outEdge Corresponding Edge
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
    Dtk_ErrorStatus GetEdge(Dtk_EdgePtr &outEdge) const;
 
     //! \brief Set Edge for coedge 
     //! \param [in] :inEdge Corresponding Edge
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
    Dtk_ErrorStatus SetEdge(const Dtk_EdgePtr &inEdge);
    Dtk_ErrorStatus SetEdge(const Dtk_ID &inEdgeId);
 
     //! \brief  Get Number of adjacent coedges
     //! \return  Number of adjacent coedges
     Dtk_Size_t GetNumAdjacentCoedges() const;
 
     //! \brief  Get adjacent coedges from index
     //! \param [in] :inIndex coedge index
     //! \param [out] :outAdjacentCoedge coedge pointer
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetAdjacentCoedge(const Dtk_Size_t &inIndex, Dtk_CoedgePtr &outAdjacentCoedge) const;
 
     //! \brief  Get parent loop 
     //! \param [out] :outParentLoop 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetParentLoop(Dtk_LoopPtr &outParentLoop) const;
     
     //! \brief  Get parent face 
     //! \param [out] :outParentFace 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetParentFace(Dtk_FacePtr &outParentFace) const;
 
     //! \brief  Get basis surface 
     //! \param [out] :outBasisSurface 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetBasisSurface(Dtk_SurfacePtr &outBasisSurface) const;
 
     //! \brief  Set parent loop 
     //! \param [in] :inParentLoop 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus SetParentLoop(const Dtk_LoopPtr &inParentLoop);
    Dtk_ErrorStatus SetParentLoop(const Dtk_ID &inParentLoopId);
 
    enum type_detk get_type_detk()  const;
    
     //! \brief Get Geometry
     //! \return Dtk_CurvePtr
   Dtk_CurvePtr GetGeom() const;
     //! \brief Set Geometry
     //! \param [in] inCurveUV : Curve UV 
    void SetGeom(const Dtk_CurvePtr& inCurveUV);
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
     Dtk_bool HasDegeneratedFlag();
}; 
 
//! \ingroup TOPO
//! \class Dtk_Loop 
//! \brief Dtk_Loop is bound of a face it can be outer or inner
//! \SmartPtr{Dtk_LoopPtr}
//!  
class Dtk_Loop : public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_LOOP }; 
 
     Dtk_ErrorStatus SetCoedge(const Dtk_Size_t &inIndex, const Dtk_CoedgePtr &inCoedge,const Dtk_bool &inOrientation);
 
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
     Dtk_Loop();
     Dtk_Loop(const Dtk_Loop &inTopo,Dtk_Body *inParentBody);
    virtual ~Dtk_Loop();
    Dtk_ErrorStatus GetParentBody(Dtk_Body* &outParentBody) const;
    friend class Dtk_SmartPtr<Dtk_Loop>;
     friend class Dtk_TopologicalEntity;
 
public:
     Dtk_ID GetTopoID() const;
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
     Dtk_ErrorStatus RemoveCoedgeFromLoop(const Dtk_CoedgePtr  &inCoedge);
 
     //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Loop * DtkDynamicCast(Dtk_Object * s);
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
     Dtk_ErrorStatus SetOuterInfo(const Dtk_bool &inIsOuter);
     type_detk get_type_detk()  const;
 
 
     //! \brief Create a loop in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_LoopPtr created
     static Dtk_LoopPtr Create(const Dtk_BodyPtr &inParentBody);
 
     //! \brief Create a loop in a body
     //! \param [in] inParentBody : parent body
     //! \param [in] inCoedgeReserve : Coedge size to reserve
     //! \return  Dtk_LoopPtr created
     static Dtk_LoopPtr Create(const Dtk_BodyPtr &inParentBody,Dtk_UInt32 inCoedgeReserve);
 
     //! \brief  Return true if Loop is outer
     Dtk_bool IsOuter() const;
     //! \brief  Return true if Loop is a vertex loop
     Dtk_bool IsVertexLoop() const;
 
     //! \brief  Return orientation for Loop relative to face
     //! \return  True if material is on the left
     Dtk_bool GetOrientation() const;
     //! \brief  Set orientation for Loop relative to face
     //! \param [in] :inOrientation True if material is on the left
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus SetOrientation(const Dtk_bool& inOrientation);
 
     //! \brief  Return number of coedge in the loop
    Dtk_Size_t GetNumCoedges() const;
     //! \brief  Get a coedge in the loop
     //! \param [in] : inIndex index of coedge to get
     //! \param [out] : outCoedge : pointer on coedge you ask
     //! \param [out] : outCoedgeOrientationIsSameAsLoop : true if coedge and loop have the same orientation
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetCoedge(const Dtk_Size_t& inIndex,Dtk_CoedgePtr &outCoedge,Dtk_bool &outCoedgeOrientationIsSameAsLoop) const;
    Dtk_ErrorStatus GetCoedge(const Dtk_Size_t& inIndex,Dtk_ID &outCoedgeId,Dtk_bool &outCoedgeOrientationIsSameAsLoop ) const;
 
 
     //! \brief  Get an index of a coedge in the loop
     //! \param [in] : inCoedge : pointer on coedge you want the index
     //! \param [out] : outIndex index of the coedge
     //! \return  Dtk_ErrorStatus: dtkNoError if found
     Dtk_ErrorStatus GetCoedgeIndex(Dtk_CoedgePtr &inCoedge, Dtk_Size_t& outIndex) const;
 
 
     //! \brief  Add coedge to the loop
     //! \param [in] : inCoedge : pointer on coedge you add
     //! \param [in] : inCoedgeOrientation : orientation of coedge in the loop (true is loop and coedge have the same orientation)
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus AddCoedge(const Dtk_CoedgePtr &inCoedge,const Dtk_bool &inCoedgeOrientation);
     Dtk_ErrorStatus SetCoedges(const Dtk_tab<Dtk_CoedgePtr>& inCoedgeArray,const Dtk_tab<Dtk_bool > &inCoedgeOrientationArray);
 
     //! \brief  Return vertex loop
     //! \param [out] : outVertexLoop : pointer on vertex loop
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetVertexLoop(Dtk_VertexPtr &outVertexLoop) const;
     //! \brief  Set vertex loop
     //! \param [in] : inVertexLoop : pointer on vertex loop
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus SetVertexLoop(const Dtk_VertexPtr inVertexLoop);
 
     //! \brief  Return an array of consecutive UV curves representing the loop 
     //! \param [out]: outUVBound : array of consecutive UV curves
     //! \param [in]: inComputeFlag : Force computation if not filled
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus ComputeUVBoundaries(Dtk_tab<Dtk_CurvePtr> &outUVBound,Dtk_bool inComputeFlag=0) const;
     //! \brief  Return an array of consecutive 3D curves representing the loop 
     //! \param [out]: out3DBound : array of consecutive 3D curves
     //! \param [in]: inComputeFlag : Force computation if not filled
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus Compute3DBoundaries(Dtk_tab<Dtk_CurvePtr> &out3DBound,Dtk_bool inComputeFlag=0) const;
 
     //! \brief  Return pointer on parent face 
     //! \param [out]: outParentFace : parent face
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetParentFace(Dtk_FacePtr &outParentFace) const;
 
     //! \brief  Set pointer on parent face 
     //! \param [in]: inParentFace : parent face
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus SetParentFace(const Dtk_FacePtr &inParentFace);
    Dtk_ErrorStatus SetParentFace(const Dtk_ID &inParentFaceId);
 
     //! \brief  Inverse sens of all coedges in the loop
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus InverseCoedgeOrientation() const;
 
     //! \brief  Compute bounding Box of UV Boundaries if they exist
     //! \param [out]: outMin : Umin and Vmin coordinates
     //! \param [out]: outMax : Umax and Vmax coordinates
     //! \param [in]: inComputeFlag : TRUECompute Uv boundaries if doesn't exist
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus ComputeUVBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax,Dtk_bool inComputeFlag = DTK_FALSE);
 
     //! \brief  Compute bounding Box of 3d Boundaries if they exist
     //! \param [out]: outMin : Umin and Vmin coordinates
     //! \param [out]: outMax : Umax and Vmax coordinates
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup TOPO
//! \class Dtk_Face 
//! \brief is a surface bounded by Dtk_Loop. 
//! \brief Geometrical orientation relative to basis surface is always True
//!  \SmartPtr{Dtk_FacePtr}
class Dtk_Face:public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_FACE }; 
 
     Dtk_ErrorStatus SetLoop(const Dtk_Size_t &inIndex, const Dtk_LoopPtr &inLoop);
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
    friend class Dtk_SmartPtr<Dtk_Face>;
     friend class Dtk_TopologicalEntity;
 
    //constructors
    Dtk_Face();
     Dtk_Face(const Dtk_Face &inTopo,Dtk_Body *inParentBody);
 
    virtual ~Dtk_Face();
public:
     Dtk_ID GetTopoID() const;
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
     Dtk_ErrorStatus RemoveLoopFromFace(const Dtk_LoopPtr  &inLoop);
 
     //! \brief Create a face in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_FacePtr created
    static Dtk_FacePtr Create(const Dtk_BodyPtr &inParentBody);
 
     //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Face * DtkDynamicCast(Dtk_Object * inObject);
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
 
     //! \brief  Return number of parent shell (1 if manifold body) 
     Dtk_Size_t GetNumParentShells() const;
 
     //! \brief  Get parent shell of face
     //! \param [in] : inIndex : index of parent shell 
     //! \param [out] : outParentShell : parent shell 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus GetParentShell(const Dtk_Size_t & inIndex,Dtk_ShellPtr &outParentShell) const;
 
     //! \brief  Get parent shell of face
     //! \param [in] : inIndex : index of parent shell 
     //! \param [out] : outParentShell : parent shell 
     //! \param [out] : outOrient : face orientation in parent shell 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetParentShell(const Dtk_Size_t & inIndex,Dtk_ShellPtr &outParentShell, Dtk_bool& outOrient) const;
 
     //! \brief  Add parent shell on a face
     //! \param [in] : inParentShell shell to add
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus AddParentShell(const Dtk_ShellPtr &inParentShell);
    Dtk_ErrorStatus AddParentShell(const Dtk_ID &inParentShellId);
 
     //! \brief  Return number of bounding loop for face
     Dtk_Size_t GetNumLoops() const;
 
     //! \brief  Get loop of face
     //! \param [in] : inIndex : index of loop 
     //! \param [out] : outLoop : loop
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus GetLoop(const Dtk_Size_t& inIndex,Dtk_LoopPtr &outLoop) const;
    Dtk_ErrorStatus GetLoop(const Dtk_Size_t & inIndex,Dtk_ID &outLoopId) const; 
     //! \brief  Add Degenerated UV curves in loops
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
     Dtk_ErrorStatus AddDegeneratedEdges() const;
 
     //! \brief  Add inner loop on a face
     //! \param [in] : inLoop :  inner loop to add
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus AddInnerLoop(const Dtk_LoopPtr &inLoop);
     //! \brief  Add outer loop on a face
     //! \param [in] : inLoop :  outer loop to add
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus AddOuterLoop(const Dtk_LoopPtr &inLoop);
     //! \brief  Add vertex loop on a face
     //! \param [in] : inLoop :  vertex loop to add
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus AddVertexLoop(const Dtk_VertexPtr &inVertexLoop);
     //! \brief  Add  loop on a face
     //! \param [in] : inLoop :  loop to add
     //! \param [in] : inOuterInfo :  outer info for inLoop (True if outer)
     //! \return  Dtk_ErrorStatus: dtkNoError if OK
    Dtk_ErrorStatus AddLoop(const Dtk_LoopPtr & inLoop,const Dtk_bool& inOuterInfo);
 
     enum type_detk get_type_detk()  const;
 
     //! \brief  Return associated geometry 
     //! \param [in] : inWithSetTrim if DTK_TRUE surface set trimuvbox like the face
     //! \return  Dtk_SurfacePtr 
     Dtk_SurfacePtr GetGeom( Dtk_bool inWithSetTrim = DTK_TRUE ) const;
     //! \brief Set Geometry
     //! \param [in] inSurface : Basis Surface 
     //! \return  void 
    void SetGeom(const Dtk_SurfacePtr& inSurface);
 
     //! \brief Get Surface Trim Box  : Umin = outTrimValues[0]  Umax = outTrimValues[1] Vmin = outTrimValues[2]  Vmax = outTrimValues[3]
     Dtk_ErrorStatus GetTrimUVBox(Dtk_Double64 outTrimValues[]) const; 
     //! \brief Set Surface Trim Box  : Umin = inTrimValues[0]  Umax = inTrimValues[1] Vmin = inTrimValues[2]  Vmax = inTrimValues[3]
     Dtk_ErrorStatus SetTrimUVBox(Dtk_Double64 inTrimValues[]);
 
     //! \brief Create a new face with reversed surface
     //! \return  a new single face with reversed normal 
     Dtk_FacePtr ReverseNormal() const;
 
    Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
 
     //! \brief  Remove a Shell to Shell's list of face
     //! \param [in] :inShellId 
     void RemoveParentShell( const Dtk_ID &inShellId );
};
 
 
 
//! \ingroup TOPO
//! \class Dtk_Volume 
//! \brief A Dtk_Volume is a space limited by edges. It contain one or several Dtk_Shell. 
//! If two objects have a common face without common edge you have to create 2 volumes.
//! \SmartPtr{Dtk_VolumePtr}
class Dtk_Volume:public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_VOLUME }; 
 
     Dtk_Volume(const Dtk_Volume& inEdgeTpCopy, Dtk_Body *inParentBody);
     Dtk_Volume();  
    virtual ~Dtk_Volume();
    Dtk_ErrorStatus GetParentBody(Dtk_Body* &outParentBody) const;
    friend class Dtk_SmartPtr<Dtk_Volume>;
     friend class Dtk_TopologicalEntity;
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
public:
     Dtk_ID GetTopoID() const;
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr&  inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
     //! \brief Create a volume in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_VolumePtr created
    static Dtk_VolumePtr Create(const Dtk_BodyPtr &inParentBody);
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Volume * DtkDynamicCast(Dtk_Object * inObject);
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
 
     //! \brief Get Parent Lump
     //! \param [out] outParentLump : parent lump
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
     Dtk_ErrorStatus GetParentLump(Dtk_LumpPtr &outParentLump) const;
     //! \brief Set Parent Lump
     //! \param [in] inParentLump : parent lump
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
    Dtk_ErrorStatus SetParentLump(const Dtk_LumpPtr& inParentLump);
    Dtk_ErrorStatus SetParentLump(const Dtk_ID& inParentLumpId);
 
     //! \brief Get Number of Shell in Volume
     //! \return  Number of Shell in Volume
    Dtk_Size_t GetNumShells() const;
 
     //! \brief Get Shell
     //! \param [in] inIndex : index of shell 
     //! \param [out] outShell : pointer on shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
    Dtk_ErrorStatus GetShell(const Dtk_Size_t& inIndex,Dtk_ShellPtr &outShell) const; 
    Dtk_ErrorStatus GetShell(const Dtk_Size_t& inIndex,Dtk_ID &outShellId) const; 
 
     //! \brief Add Open Shell (only one supported) 
     //! \param [in] inShell : pointer on outer shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  error if body has already a closed (inner or outer )shell    
    Dtk_ErrorStatus AddOpenShell(const Dtk_ShellPtr &inShell);
     //! \brief Add Outer Shell (only one supported) 
     //! \param [in] inShell : pointer on outer shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  error if body has already an open shell or an outer shell
    Dtk_ErrorStatus AddOuterShell(const Dtk_ShellPtr &inShell);
     //! \brief Add Inner Shell 
     //! \param [in] inShell : pointer on inner shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  
    Dtk_ErrorStatus AddInnerShell(const Dtk_ShellPtr &inShell);
     //! \brief Add Wire Shell 
     //! \param [in] inShell : pointer on inner shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  
     Dtk_ErrorStatus AddWireShell(const Dtk_ShellPtr &inShell);
 
    enum type_detk get_type_detk() const;
    Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup TOPO
//! \class Dtk_Lump 
//! \brief A Dtk_Lump is a manifold part of a non manifold object
//! If two volumes have a common edge you have to create two lumps with a volume in each
//! \SmartPtr{Dtk_LumpPtr}
class Dtk_Lump:public Dtk_TopologicalEntity
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_LUMP }; 
 
     Dtk_Lump();
     Dtk_Lump(const Dtk_Lump& inLumpToCopy,Dtk_Body *inParentBody);
    virtual ~Dtk_Lump();
    friend class Dtk_SmartPtr<Dtk_Lump>;
     friend class Dtk_TopologicalEntity;
     void _Clone( Dtk_TopologicalEntityPtr &outTopo,Dtk_Body * _inParentBody);
 
public:
     Dtk_ID GetTopoID() const;
 
     //! \brief Create a lump in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_LumpPtr created
    static Dtk_LumpPtr Create(const Dtk_BodyPtr &inParentBody);
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Lump * DtkDynamicCast(Dtk_Object * inObject);
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
 
     //! \brief Get Number of Volumes in lump 
     //! \return  Number of Volumes in lump   
    Dtk_Size_t GetNumVolumes() const;
     //! \brief Get Volume
     //! \param [in] inIndex : index of volume 
     //! \param [out] outVolume : pointer on volume
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
    Dtk_ErrorStatus GetVolume(const Dtk_Size_t inIndex,Dtk_VolumePtr &outVolume) const; 
    Dtk_ErrorStatus GetVolume(const Dtk_Size_t inIndex,Dtk_ID &outVolumeId) const; 
     //! \brief Add Volume
     //! \param [in] inVolume : pointer on volume
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
     Dtk_ErrorStatus AddVolume(const Dtk_VolumePtr &inVolume);
     //! \brief Get Parent Body
     //! \param [out] outParentBody : parent body
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
    Dtk_ErrorStatus GetParentBody(Dtk_BodyPtr &outParentBody) const;
     //! \brief Set Parent Body
     //! \param [in] inParentBody : parent body
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
    Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
    enum type_detk get_type_detk() const;
    Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup TOPO
//! \class Dtk_Body 
//! \brief A Dtk_Body Dtk_Body is the highest level topological entity. 
//! It allow you to handle manifold and non-manifold object , open skin or surfacic model  and wire entities.
//! \SmartPtr{Dtk_BodyPtr}
class Dtk_Body:public Dtk_Entity
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_BODY }; 
 
     //! \sa Create( const Dtk_Body& )
     Dtk_Body(const Dtk_Body& );
     Dtk_Body( Dtk_Body&& in ) DTK_NOEXCEPT;
    virtual ~Dtk_Body();
    friend class Dtk_SmartPtr<Dtk_Body>;
    inline virtual Dtk_Object* Clone() { return new Dtk_Body(*this); }
public:
    Dtk_Body();
 
     //! \brief Create a body
     //! \return Dtk_BodyPtr created
    static Dtk_BodyPtr Create();
     //! \CreateCopy{ in }
    static Dtk_BodyPtr Create( const Dtk_Body& in );
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Body*  DtkDynamicCast(Dtk_Object * inObject);
 
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
    Dtk_ErrorStatus GetBodyStatus() const;
    Dtk_ErrorStatus SetBodyStatus(Dtk_ErrorStatus inBodyStatus);
    Dtk_Size_t GetNumLumps() const;
    Dtk_ErrorStatus GetLump(const Dtk_Size_t& inIndex,Dtk_LumpPtr &outLump) const; 
    Dtk_ErrorStatus GetLump(const Dtk_Size_t& inIndex,Dtk_ID &outLumpId) const; 
    Dtk_ErrorStatus AddLump(const Dtk_LumpPtr &inLump);
    Dtk_TopologicalEntityPtr GetPtr(const Dtk_ID& inId) const;
     Dtk_ID AddPtr(const Dtk_TopologicalEntityPtr &outEntityPtr);
 
     //! \brief Add Shell in Body in first volume of first lump (created if none)
     //! \param [in] inShell : pointer on inner shell
     //! \param [in] inOuterInfo : DTK_TRUE if outer  - DTK_FALSE if inner not yet supported -
     //! \param [in] inClosedInfo : DTK_TRUE if closed DTK_FALSE if open
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  error if body has 2 open shell or 2 outer shell or dtkWarningTopologyIncomplete if inOuterInfo == DTK_FALSE
     //! \deprecated Use Dtk_Body::AddOpenShell, Dtk_Volume::AddOuterShell or Dtk_Volume::AddInnerShell to get valid topology
     SetAsDeprecated("2025.1", "Use Dtk_Body::AddOpenShell, Dtk_Volume::AddOuterShell or Dtk_Volume::AddInnerShell to get valid topology")
     Dtk_ErrorStatus AddShell(const Dtk_ShellPtr &inShell, const Dtk_bool &inOuterInfo,const Dtk_bool &inClosedInfo);
     //
     //! \brief Add Open Shell in first volume of first lump (created if none)
     //! \param [in] inShell : pointer on outer open shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  error if body has already a closed (inner or outer )shell    
     Dtk_ErrorStatus AddOpenShell(const Dtk_ShellPtr &inShell);
     Dtk_ErrorStatus AddOpenShell2(const Dtk_ShellPtr &inShell, Dtk_VolumePtr &volume);
 
     //! \brief Return Number of Open Shell
     //! \return  Dtk_Size_t 
    Dtk_Size_t GetNumOpenShells()const;
    //! \brief Return Open Shell 
     //! \param [in] inIndex : index of Open Shell 
     //! \param [out] outShell : pointer on open shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
     Dtk_ErrorStatus GetOpenShell(Dtk_Size_t inIndex,Dtk_ShellPtr &outShell)const;
 
     //! \brief Add Open Shell with a one Unbounded Surface
     //! \param [in] inSurface : pointer on surface
     //! \param [in] InOrient : Face orientation relative to shell (DTK_TRUE if face material and shell material are on same side)
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  error if body has already a shell
     Dtk_ErrorStatus AddUnboundedFace(Dtk_SurfacePtr inSurface, Dtk_bool InOrient = DTK_TRUE);
 
     //! \brief Add Wire Shell 
     //! \param [in] inShell : pointer on wire shell
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
     Dtk_ErrorStatus AddWireShell(const Dtk_ShellPtr &inShell);
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
    enum type_detk get_type_detk() const;
 
     int GetWireCurves (Dtk_tab<Dtk_CurvePtr> &curves);
     int GetWireEntities (Dtk_tab<Dtk_CurvePtr> &curves,Dtk_tab<Dtk_PointPtr>& points);
    
     Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
     Dtk_ErrorStatus Store(FILE* inFile,Dtk_Size_t inIo=1);
     Dtk_ErrorStatus Store(const Dtk_string& inFile,Dtk_Size_t inIo=1);
     Dtk_ErrorStatus _Store(void *);
     virtual Dtk_Size_t GetSize() const;
 
     //! \brief Removes all references to inVertexToRemove and replace it by inVertexToKeep
     //! \param [in] inVertexToKeep : Vertex to use
     //! \param [in] inVertexToRemove : Vertex to remove
     //! \return  Dtk_ErrorStatus: dtkNoError if OK  
     Dtk_ErrorStatus MergeVertices(Dtk_VertexPtr inVertexToKeep,Dtk_VertexPtr inVertexToRemove);
 
     //! \brief Returns DTK_TRUE if Body contains faces with surfaces
     Dtk_bool HasFaces();
 
     //! \brief Returns DTK_TRUE if Body contains wireframe
     Dtk_bool HasWire();
 
     //! \brief Returns DTK_TRUE if Body contains periodic surfaces
     Dtk_bool HasPeriodicSurface();
 
     //! \brief Returns DTK_TRUE if Body contains mesh surfaces 
     Dtk_bool HasMeshSurface();
 
    //! \brief Transforms all curves and surfaces in the body into NURBS 
    //! \param [in] inRemoveTrimmedCurve : Convert Trimmed Nurbs into Nurbs
    //! \return  Dtk_ErrorStatus: dtkNoError if OK  
    Dtk_ErrorStatus ToNurbs(Dtk_bool inRemoveTrimmedCurve = 0);
 
     //! \brief Get Tolerance 
     //! \param [out] outTolerance : body tolerance
     //! \return  dtkNoError if value set or  dtkWarningDefaultValue if default
     Dtk_ErrorStatus GetTolerance(Dtk_Double64 &outTolerance) const;
 
     //! \brief Set Tolerance 
     //! \param [in] inTol : Tolerance
     void SetTolerance(Dtk_Double64 inTol);
 
     //! \brief Get Num entities 
     //! \param [in] inType : Type of entities to count
     Dtk_Size_t GetNumTopologicalEntities(type_detk inType);
 
     //! \brief Get entity with Info->GetId() ==  inInfoId
     //! \param [in] inInfoId :  Info->GetId() of entity to be found
    //! \deprecated
    //! \sa Dtk_Body::GetEntities(const Dtk_ID& inInfoId, Dtk_tab<Dtk_EntityPtr> &outTab)
     //SetAsDeprecated( L"2016.1", L"Use Dtk_Body::GetEntities instead.")
     Dtk_EntityPtr GetEntity(const Dtk_ID& inInfoId ) const;
     
    //! \brief Get entities with Info->GetId() ==  inInfoId
    //! \param [in] inInfoId : Info->GetId() of entities to be found
    //! \param [in] inLookAlsoForCurve : if set to DTK_TRUE, Dtk_Entity retrieved can also include Dtk_CurvePtr. Otherwise, only Dtk_TopologicalEntity can be retrieved.
    //! \remark : several entities can have same identifiers (e.g. splitted entities....)
    Dtk_ErrorStatus GetEntities(const Dtk_ID& inInfoId, Dtk_tab<Dtk_EntityPtr> &outTab, Dtk_bool inLookAlsoForCurve = DTK_TRUE ) const;
 
     //! \brief Fills a mapping table between Topological Entity identifiers (Dtk_ID from Dtk_Info::GetId) and the indices of corresponding entities within the Dtk_Body.
     //! This allows efficient retrieval of all entities associated with a given identifier (including cases where entities have been split).
     //!  With the retrieved positions and the function Dtk_Body::GetPtr, you can directly get the corresponding Dtk_TopologicalEntityPtr, which is faster than calling Dtk_Body::GetEntities for each identifier.
     //! \param [out] outMap : mapping table Dtk_ID -> list of entity indices in the body.
     //! \return Dtk_ErrorStatus : dtkNoError if the mapping was successfully filled
     Dtk_ErrorStatus FillTopologicalEntitiesIdMapping( std::unordered_map<Dtk_ID, std::vector<Dtk_Size_t>>& outMap );
 
     Dtk_ErrorStatus Normalize(Dtk_bool updateEdgeGeometry = DTK_TRUE);
     Dtk_ErrorStatus RevolToStandardRevol();
     Dtk_ErrorStatus TorusWithNegativeMaxRadiusToRevol();
     Dtk_ErrorStatus TrimUnlimitedFaces ();
     Dtk_ErrorStatus GetVertexBound (Dtk_pnt& pmin, Dtk_pnt& pmax);
     Dtk_ErrorStatus GetVertexGravity(Dtk_pnt& pcenter);
     Dtk_bool LimitInfinitEntities( Dtk_Double64 lenFoundMin, Dtk_Double64 lenNew = 1.0);
     Dtk_ErrorStatus ExtractEdgeBody(Dtk_BodyPtr &outEdgeBody);
     void AddStream(Dtk_StreamPtr inStream);
     Dtk_StreamPtr GetStream(Dtk_Size_t inStreamIndex) const;
     Dtk_Size_t GetNumStream()const;
 
};
 
//! \ingroup TOPO
//! \class Dtk_Shell 
//! \brief Dtk_Shell  is a set of faces bounding a volume. Dtk_Shell can be outer or inner.
//!  A Dtk_Body contain at least one open_shell or one outer closed shell and 0 or several inner closed shell.
//!  \SmartPtr{Dtk_ShellPtr}
class Dtk_Shell :public Dtk_TopologicalEntity
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_SHELL };
     void _Clone(Dtk_TopologicalEntityPtr &outTopo, Dtk_Body * _inParentBody);
 
     Dtk_Shell();
     Dtk_Shell(const Dtk_Shell &inTopo, Dtk_Body *inParentBody);
     virtual ~Dtk_Shell();
     friend class Dtk_SmartPtr<Dtk_Shell>;
     friend class Dtk_TopologicalEntity;
     friend Dtk_ErrorStatus Dtk_Body::ExtractEdgeBody(Dtk_BodyPtr &outEdgeBody);
 
     Dtk_ErrorStatus SetFace(const Dtk_Size_t &inIndex, const Dtk_FacePtr &inFace, const Dtk_bool &inFaceOrientation);
 
public:
     Dtk_ID GetTopoID() const;
     Dtk_ErrorStatus RemoveFaceFromShell(const Dtk_FacePtr  &inFace);
     Dtk_ErrorStatus InverseFaceInShell(const Dtk_FacePtr  &inFace);
 
     Dtk_ErrorStatus SetParentBody(const Dtk_BodyPtr &inParentBody);
     Dtk_BodyPtr GetParentBody() const;
 
     //! \brief Create a shell in a body
     //! \param [in] inParentBody : parent body
     //! \return Dtk_ShellPtr created
     static Dtk_ShellPtr Create(const Dtk_BodyPtr &inParentBody);
     //! \brief Create a shell in a body
     //! \param [in] inParentBody : parent body
     //! \param [in] inFacesReserve : Faces size to reserve
     //! \param [in] inWireReserve : Wire size to reserve
     //! \return Dtk_ShellPtr created
     static Dtk_ShellPtr Create(const Dtk_BodyPtr &inParentBody, Dtk_UInt32 inFacesReserve, Dtk_UInt32 inWireReserve = 0);
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Shell * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \brief Get Parent Body
     //! \param [out] outParentBody : parent body
     //! \return  Dtk_ErrorStatus: dtkNoError if OK     
     Dtk_ErrorStatus GetParentBody(Dtk_BodyPtr &outParentBody) const;
     //! \brief Return parent volume of shell
     //! \param [out] outParentVolume : pointer of parent volume
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus GetParentVolume(Dtk_VolumePtr &outParentVolume) const;
     //! \brief Set parent volume of shell
     //! \param [in] inParentVolume : pointer of parent volume
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus SetParentVolume(const Dtk_VolumePtr &inParentVolume);
     Dtk_ErrorStatus SetParentVolume(const Dtk_ID &inParentVolumeId);
 
     Dtk_ErrorStatus GetTopologyStatus() const;
     void SetTopologyStatus(Dtk_ErrorStatus inStatus);
 
     //! \brief Return DTK_TRUE if shell is closed
     Dtk_bool IsClosed()const;
     //! \brief Set Closed Info DTK_TRUE if shell is closed
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus SetClosedInfo(const Dtk_bool &inClosedInfo);
     //! \brief Return DTK_TRUE if shell is outer
     Dtk_bool IsOuter() const;
     //! \brief Return DTK_TRUE if shell has Wire entities
     Dtk_bool HasWire() const;
     //! \brief Set Outer Info DTK_TRUE if shell is outer
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus SetOuterInfo(const Dtk_bool &inOuterInfo);
     //! \brief Return Number of Faces following Face type
     //! \param [in] inFaceType : Type of face you want to count 
     //! ( DtkFaceType_Bounded = topological face / DtkFaceType_All = All Faces / DtkFaceType_Wire = Face used to store wire entities)
     //! \return number of face following Face type
     Dtk_Size_t GetNumFaces(DtkFaceType inFaceType = DtkFaceType_Bounded) const;
 
     //! \brief Return Number of Wire set of entities
     //! equivalent to GetNumFaces with type  DtkFaceType_Wire 
     //! \return number of Wire set of entities
     Dtk_Size_t GetNumWireSet() const;
 
     //! \brief Get Wire Set
     //! \param [in] inIndex : index of wire set
     //! \param [out] outWire : array of Dtk_Entity (must be Dtk_PointPtr or Dtk_CurvePtr )
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus GetWireSet(const Dtk_Size_t & inIndex, Dtk_tab<Dtk_EntityPtr> &outWire) const;
 
 
     //! \brief Get Wire Set
     //! \param [in] inIndex : index of wire set
     //! \param [out] outWire : array of Dtk_Entity (must be Dtk_VertexPtr or Dtk_EdgePtr )
     //! \param [out] outOrientation : array of bool for edge orientation 
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus GetWireSetTopo(const Dtk_Size_t& inIndex, Dtk_tab<Dtk_EntityPtr>& outWire, Dtk_tab<Dtk_bool>& outOrientation, Dtk_bool &outLoopOrientation) const;
     Dtk_ErrorStatus GetWireSetTopo(const Dtk_Size_t& inIndex, Dtk_tab<Dtk_EntityPtr>& outWire) const;
 
     //! \brief Get Face following Face type
     //! \param [in] inIndex : index of face
     //! \param [out] outFace : Face
     //! \param [out] outOrientation : Face orientation relative to shell
     //! \param [in] inFaceType : Type of face ( DtkFaceType_Bounded = topological face / DtkFaceType_All = All Faces / DtkFaceType_Wire = Face used to store wire entities)
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus GetFace(const Dtk_Size_t & inIndex, Dtk_FacePtr &outFace, Dtk_bool &outOrientation, DtkFaceType inFaceType = DtkFaceType_Bounded) const;
     Dtk_ErrorStatus GetFace(const Dtk_Size_t & inIndex, Dtk_ID &outFaceId, Dtk_bool &outOrientation, DtkFaceType inFaceType = DtkFaceType_Bounded) const;
 
     //! \brief Add Face to shell
     //! \param [in] inFace : Face
     //! \param [in] inOrientation : Face orientation relative to shell (DTK_TRUE if face material and shell material are on same side)
     //! \param [in] inFaceType : Type of face ( DtkFaceType_Bounded = topological face or DtkFaceType_Wire = Face used to store wire entities)
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus AddFace(const Dtk_FacePtr &inFace, Dtk_bool inFaceOrientation, DtkFaceType inFaceType = DtkFaceType_Bounded);
     
     //! \brief Add Wire entities
     //! \param [in] inWireArray : Array of Dtk_Curves
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus AddWire(Dtk_tab<Dtk_CurvePtr> inCurveArray);
     Dtk_ErrorStatus AddWire(Dtk_tab<Dtk_EdgePtr> inCurveArray);
 
     //! \brief Add Wire entities
     //! \param [in] inPointArray : Array of 3D Points
     //! \return  Dtk_ErrorStatus: dtkNoError if OK 
     Dtk_ErrorStatus AddWire(Dtk_tab<Dtk_PointPtr> inPointArray);
     Dtk_ErrorStatus AddWire(Dtk_tab<Dtk_VertexPtr> inPointArray);
 
     //! \brief Check if Shell is Closed
     //! \return  DTK_TRUE if closed
     Dtk_bool CheckIfClosed();
 
     enum type_detk get_type_detk() const;
     Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax);
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
 
#endif