util_geom_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_GEOM_DTK_HPP_
#define _UTIL_GEOM_DTK_HPP_
 
#include "util/util_geom_ptr_dtk.hpp"
#include"util/util_mesh_dtk.hpp"
#include <memory>
#include <vector>
 
#include <assert.h>
class Dtk_2dpnt;
 
 
/***************************************   POINTS **********************************/
 
//! \ingroup geom
//! \class Dtk_Point 
//! \brief This class represent a point coordinates and information.
//! It is part of the Dtk_Vertex entity
//! \SmartPtr{Dtk_PointPtr}
//!
class Dtk_Point : public Dtk_Entity
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_POINT }; 
    Dtk_Point();
    Dtk_Point(const Dtk_Point& s);
    Dtk_Point(Dtk_Point&& in) DTK_NOEXCEPT;
    virtual ~Dtk_Point();
    inline virtual Dtk_Object* Clone() { return new Dtk_Point(*this); }
 
private:
    friend class Dtk_SmartPtr<Dtk_Point>;
public:
     //! \brief constructors 
    Dtk_Point(const Dtk_pnt& pt);
 
    //! \brief downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Point * DtkDynamicCast(Dtk_Object * inObject);
 
 
     //! \CreateCopy{in}
    static Dtk_PointPtr Create(const Dtk_Point& in );
    static Dtk_PointPtr Create(const Dtk_pnt& in );    
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_PointPtr Create(const Dtk_Double64 & inX, const Dtk_Double64 & inY, const Dtk_Double64 & inZ);
 
    //methods
     //! \brief Get Coordinates For Point
    Dtk_ErrorStatus GetCoordinates(Dtk_Double64 &x, Dtk_Double64 &y, Dtk_Double64 &z) const;
    Dtk_ErrorStatus GetCoordinates(Dtk_pnt &pnt) const;
 
     //! \brief Transform Point
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     //! \brief Return type
    type_detk get_type_detk() const;
 
     //! \brief Dump entity 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const; 
};
 
/***************************************   CURVES **********************************/
 
//! \ingroup geom
//! \class Dtk_Curve 
//! \brief Dtk_Curve is a geometrical entity representing a curve. It is an abstract class that cannot be instancied.  \n
//! It has several utility methods :\n
//!
//!- GetDomain  allow you to get the whole definition domain for the curve.
//!\code
//!Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
//!\endcode
//!- SetTrimmingParameters/GetTrimUMin/GetTrimUMax  allow you to specify/get the used domain for the curve.
//!\code
//!Dtk_ErrorStatus SetTrimmingParameters(const Dtk_Double64& inUmin,const Dtk_Double64& inUmax);
//!Dtk_Double64 GetTrimUMin() const;
//!Dtk_Double64 GetTrimUMax() const;
//!\endcode
//!- ToNurbs convert the curve into nurbs curve.
//!- ToPolyline convert the curve into polyline .
 
class Dtk_Curve : public Dtk_Entity
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_CURVE }; 
    Dtk_Curve();
    Dtk_Curve(const Dtk_Curve& s);
    Dtk_Curve(Dtk_Curve&& in) DTK_NOEXCEPT;
    virtual Dtk_Object* Clone() = 0;
 
private:
    friend class Dtk_SmartPtr<Dtk_Curve>;
public:
    virtual ~Dtk_Curve();
    //! \brief downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Curve * DtkDynamicCast(Dtk_Object * inObject);
 
    //methods
     //! \brief Set Trim points for curve
    void SetTrimPoints(const Dtk_pnt& inStartPoint,const Dtk_pnt& inEndPoint);
     //! \brief Return DTK_TRUE if Curve Is trimmed by point or parameter value
    Dtk_bool IsTrimmed()const;
     //! \brief Return first trim point
    Dtk_pnt GetTrimStartPoint() const;
     //! \brief Return last trim point
    Dtk_pnt GetTrimEndPoint() const;
     //! \brief Return 2 or 3
    Dtk_Size_t GetDimension() const;
     //! \brief Set curve dimension (2 or 3)
    void SetDimension(const Dtk_Size_t& inDimension);
     //! \brief Set Trim parameter for curve 
    virtual Dtk_ErrorStatus SetTrimmingParameters(const Dtk_Double64& inUmin,const Dtk_Double64& inUmax);
     //! \brief Get start Trim parameter 
    Dtk_Double64 GetTrimUMin() const;
     //! \brief Get end Trim parameter 
    Dtk_Double64 GetTrimUMax() const;
    virtual Dtk_ErrorStatus InverseTrim();
     //! \brief return True if Curve is a line
    Dtk_bool IsLine();
     //! \brief return curve Length
    Dtk_Double64 ComputeLength(); 
     //! \brief return True if Curve is periodic
    virtual Dtk_bool IsPeriodic() const;
    //! \brief return True if Curve is closed
    virtual Dtk_bool IsClosed(Dtk_Double64 inTol=DTK_TOLERANCE) const;
     //! \brief Compute offset curve and convert it to nurbs
     Dtk_NurbsCurvePtr ComputeOffset(Dtk_Double64 inOffset, Dtk_dir inOffsetDirection);
 
    //virtual methods
     //! \brief Compute Bounding Box
     virtual Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax,Dtk_bool inMorePrecise = 0);
     //! \brief Compute Oriented Bounding Box
     virtual Dtk_ErrorStatus ComputeOrientedBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax, const Dtk_transfo& inLocal);
     //! \brief Get Curve Parametrisation 
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const = 0;
     //! \brief Convert Curve to polyline
     //! \param [in] inMinPoint : Minimal number of result points 
     //! \param [in] inTolerance : max tolerance for 3 points alignement.
     virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const =0 ;
     //! \brief Convert Curve to nurbs
     virtual Dtk_NurbsCurvePtr ToNurbs()const =0 ;
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const =0 ; 
     //! \brief Compute point on U parameter
    virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const =0 ; 
     //! \brief Compute dir on U parameter
     virtual Dtk_ErrorStatus ComputeUDir(const Dtk_Double64& inU,Dtk_dir& outDir) const; 
     //! \brief Compute point and dir on U parameter
     virtual Dtk_ErrorStatus ComputeUPointDir(const Dtk_Double64& inU,Dtk_pnt& outPoint,Dtk_dir& outDir)const ; 
     //! \brief Return First point
    virtual Dtk_pnt ComputeStartPoint()const =0 ; 
     //! \brief Return Last point
     virtual Dtk_pnt ComputeEndPoint()const =0 ; 
     //! \brief Reverse Curve
     virtual void Reverse()=0 ; 
     //! \brief Normalize Curve
     virtual void Normalize(); 
 
    //! \brief Transform Curve
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     //  \brief To Dump Curve
     virtual Dtk_ErrorStatus _Store(void*);
     friend void PDtk_StoreDataCurve(void*,Dtk_CurvePtr&);
     virtual Dtk_Size_t GetSize() const;
     void DeleteCorrespondingNurbs();
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, int inUdiff,Dtk_dir &outdir,int exttype) const;
};
 
//! \ingroup geom
//! \class  Dtk_NurbsCurve
//! \brief This is the Nurbs Class.
//! \SmartPtr{Dtk_NurbsCurvePtr}
//!
class Dtk_NurbsCurve : public Dtk_Curve
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_NURBS_CURVE }; 
    Dtk_NurbsCurve();
    Dtk_NurbsCurve(const Dtk_NurbsCurve& s);
     Dtk_NurbsCurve(Dtk_NurbsCurve&& in) DTK_NOEXCEPT;
    virtual ~Dtk_NurbsCurve();
    Dtk_NurbsCurve(const Dtk_UInt32& inDegree,const Dtk_tab<Dtk_Double64> &inKnots,const Dtk_tab<Dtk_pnt> &inControlPoints,const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>());
    Dtk_NurbsCurve(const Dtk_UInt32& inDegree,const Dtk_tab<Dtk_Double64>& inKnotsValues,const Dtk_tab<Dtk_UChar8>& inKnotsMultiplicities,const Dtk_tab<Dtk_pnt> &inControlPoints,const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>());
     Dtk_NurbsCurve(const Dtk_tab<Dtk_CurvePtr> &inCurvesToMerge, Dtk_Double64 stichtol /*= DTK_TOLERANCE*/, Dtk_bool LengthParameter /* DTK_FALSE*/ );
    inline virtual Dtk_Object* Clone() { return new Dtk_NurbsCurve(*this); }
private:
     Dtk_ErrorStatus _ComputeUPointDirClamp(const Dtk_Double64& inUparameter,Dtk_pnt& outPoint,Dtk_dir& outDir)const;
     void _SetNodalVector(const Dtk_tab<Dtk_Double64>& inKnotsVector);
    void _SetNodalVector(const Dtk_Double64 * inNodalVector,const Dtk_Size_t &inSize);
    void _AddKnot(const Dtk_UInt32& inKnotMultiplicity,const Dtk_Double64& inKnotValue);
    void _SetPointsArray(const Dtk_tab<Dtk_pnt> &inPointArray);
     void _SetPointsArray(Dtk_pnt *inPoints,const Dtk_Size_t &inSize);
    void _SetWeight(const Dtk_Size_t& inIndex,Dtk_Double64 inWeight) ;
    void _SetWeightsArray(const Dtk_tab<Dtk_Double64>& inWeightArray) ;
     void _SetWeightsArray(Dtk_Double64 * inWeights,const Dtk_Size_t &inSize) ;
    friend class Dtk_SmartPtr<Dtk_NurbsCurve>;
public:
     Dtk_ErrorStatus _KnotInsertion(const Dtk_Double64 &inUparameter,const Dtk_Size_t &inOccurence,Dtk_Double64 inTolerance=DTK_TOLERANCE);
     Dtk_ErrorStatus _DegreeElevation(const Dtk_Size_t &inDegreeElevation);
     int _KnotRemoval(const Dtk_Double64 &inU,const int &inNum,const Dtk_Double64 &inTolerance);
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_NurbsCurve * DtkDynamicCast(Dtk_Object *inObject);
 
    //constructors
     //! \CreateCopy{in}
    static Dtk_NurbsCurvePtr Create(const Dtk_NurbsCurve& in);
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_NurbsCurvePtr Create(const Dtk_UInt32& inDegree,const Dtk_tab<Dtk_Double64> &inKnots,const Dtk_tab<Dtk_pnt> &inControlPoints,const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>());
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_NurbsCurvePtr Create(const Dtk_UInt32& inDegree,const Dtk_tab<Dtk_Double64> &inKnotsValues,const Dtk_tab<Dtk_UChar8> &inKnotsMultiplicities,
          const Dtk_tab<Dtk_pnt> &inControlPoints,const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>());
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_NurbsCurvePtr Create(const Dtk_NurbsCurvePtr& s,const Dtk_tab<Dtk_Double64>& inKnotsValues,const Dtk_tab<Dtk_UChar8>& inKnotsMultiplicities);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_NurbsCurvePtr Create(const Dtk_tab<Dtk_CurvePtr> &inCurvesToMerge, Dtk_Double64 stichtol = DTK_TOLERANCE, Dtk_bool LengthParameter =  DTK_FALSE );
 
 
    //methods
    //! \brief  return degree
    Dtk_UInt32 GetDegree() const;
     //! \brief  return number of different knot value
    Dtk_Size_t GetNumKnots() const;
     //! \brief  return knot value at inIndex place
    Dtk_Double64 GetKnotValue(const Dtk_Size_t& inIndex) const;
     //! \brief  return knot multiplicity at inIndex place
    Dtk_UInt32 GetKnotMultiplicity(const Dtk_Size_t& inIndex) const;
    //! \brief  return Num Control points
     Dtk_Size_t GetNumPoints() const;
    //! \brief Set Curve parametrisation domain
    Dtk_ErrorStatus Reparam(const Dtk_Double64 &inUmin,const Dtk_Double64 &inUmax);
    //! \brief  return the point at place inIndex 
    const Dtk_pnt& Point(const Dtk_Size_t& inIndex) const;
    Dtk_pnt& Point(const Dtk_Size_t& inIndex);
    //! \brief  return weight
    Dtk_Double64 GetWeight(const Dtk_Size_t& inIndex) const;
 
    //! \brief  return DTK_TRUE if one weight != 1
    Dtk_bool IsRationnal() const;
     //! \brief  return DTK_TRUE if bezier
    Dtk_bool IsBezier() const;
     //! \brief  return DTK_TRUE if knots are uniform
    Dtk_bool IsUniform() const;
     //! \brief  return DTK_TRUE if nurbs is line
     Dtk_bool IsLine() const;
     //! \brief  return DTK_TRUE if nurbs is closed
     Dtk_bool IsClosed(Dtk_Double64 inTol=DTK_TOLERANCE) const;
     //! \brief  return DTK_TRUE if nurbs is periodic
     virtual Dtk_bool IsPeriodic() const;
 
    //! \brief  sets is_closed field to DTK_TRUE or DTK_FALSE
    void SetIsPeriodic(const Dtk_bool &inIsPeriodic);
     //! \brief  sets is_closed field to DTK_TRUE or DTK_FALSE
     void SetIsClosed(const Dtk_bool &inIsClosed);
     //! \brief  return DTK_TRUE if nurbs can have discontinuity
     Dtk_bool CanHaveDiscontinuity( )const;
 
     Dtk_ErrorStatus ComputeUPointDir(const Dtk_Double64& inUparameter,Dtk_pnt& outPoint,Dtk_dir& outDir)const;
     Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax, Dtk_bool inMorePrecise = 0);
 
     //! \brief Get Curve Parametrisation 
    virtual Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
 
     //! \brief Convert Curve to polyline
    virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
     //! \brief Convert Curve to nurbs
    virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
     //! \brief Compute point on U parameter
    virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute dir on U parameter
     virtual Dtk_ErrorStatus ComputeUDir(const Dtk_Double64& inU,Dtk_dir& outDir) const; 
     //! \brief Compute pparameter
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outParameter)const;
     //! \brief Return First point
    virtual Dtk_pnt ComputeStartPoint() const; 
     //! \brief Return Last point
   virtual Dtk_pnt ComputeEndPoint() const; 
   //! \brief Reverse Curve
    virtual void Reverse(); 
 
     Dtk_Double64 *GetUnpackedKnot() const;
 
 
    //! \brief Transform Curve
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
    //! \brief Return Curve type
     type_detk get_type_detk() const;
     void SetTypeBeforeConversion(const type_detk& inType);
    type_detk GetTypeBeforeConversion() const;
 
     //  \brief To Dump Curve
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
 
     Dtk_ErrorStatus Split(Dtk_Double64 inTrimDom[2],Dtk_Double64 inTolerance=DTK_TOLERANCE);
     //! \brief Compute any derivative for an U value outside of the curve definition
     //! \param [in] inUvalue : the U value
     //! \param [in] inUdiff : wanted derivative (0 = point, 1 = Udir or tangent, 2 = second derivative, etc.)
     //! \param [out] outdir : the computed derivative
     //! \param [in] exttype : for internal use
     Dtk_ErrorStatus _ComputeAnyDerivativeExtended(Dtk_Double64 inUvalue, int inUdiff,Dtk_dir &outdir,int exttype) const;
     //! \brief Compute any derivative for an U value
     //! \param [in] inUvalue : the U value
     //! \param [in] inUdiff : wanted derivative (0 = point, 1 = Udir or tangent, 2 = second derivative, etc.)
     //! \param [out] outdir : the computed derivative
     //! \param [in] exttype : for internal use
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, int inUdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_Double64 _ComputeWeight(Dtk_Double64 inUvalue, int exttype) const;
 
     Dtk_NurbsCurvePtr ForceG1Continuity() const;
};
 
//! \ingroup geom
//! \class  Dtk_Polyline
//! \brief This is the Polyline and Segment Line Class.
//! \SmartPtr{Dtk_PolylinePtr}
//!
class Dtk_Polyline : public Dtk_Curve
{
protected:
    //! \brief Not defined here   
    struct Dtk_Handle;       
    //! \brief Handle   
     std::unique_ptr<Dtk_Handle> _Private;  
    //! \brief Entity Type
    enum { _typeID = DTK_TYPE_POLYLINE }; 
    Dtk_Polyline();
    Dtk_Polyline(const Dtk_Polyline& inPolylineToCopy);
     Dtk_Polyline(Dtk_Polyline&& in) DTK_NOEXCEPT;
    Dtk_Polyline( Dtk_tab<Dtk_pnt> inPoints );
    Dtk_Polyline(const Dtk_pnt &inPnt1, const Dtk_pnt &inPnt2);
    inline virtual Dtk_Object* Clone() { return new Dtk_Polyline(*this); }
    //! \brief Default destructor
    virtual ~Dtk_Polyline();
private:
    //! \brief  smart pointer
    friend class Dtk_SmartPtr<Dtk_Polyline>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Polyline * DtkDynamicCast(Dtk_Object * inObjectToCast);
 
    //! \CreateCopy{in}
    static Dtk_PolylinePtr Create( const Dtk_Polyline& in );
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_PolylinePtr Create( Dtk_tab<Dtk_pnt> inPoints );
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_PolylinePtr Create( const Dtk_pnt &inPnt1, const Dtk_pnt &inPnt2 );
 
    //methods
    //! \brief  return DTK_TRUE if polyline is a line DTK_FALSE otherwise
    Dtk_bool IsLine() const;
    //! \brief  return number of points for the polyline
    Dtk_Size_t GetNumPoints() const;
    //! \brief  Add point to polyline
    void AddPoint(const Dtk_pnt& inNewPoint);
    void AddPoint(const Dtk_Double64& inX,const Dtk_Double64& inY,const Dtk_Double64& inZ=0.0);
 
    //! \brief  return the point at place inIndex 
    const Dtk_pnt& Point(const Dtk_Size_t& inIndex) const;
    Dtk_pnt& Point(const Dtk_Size_t& inIndex);
 
    virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
    virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const; 
    virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute dir on U parameter
    virtual Dtk_pnt ComputeStartPoint() const; 
    virtual Dtk_pnt ComputeEndPoint() const; 
    virtual void Reverse(); 
     Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax, Dtk_bool inMorePrecise = 0);
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 u, int inUdiff,Dtk_dir &outdir,int exttype) const;
 
 
     //! \brief Get Curve Parametrisation 
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
 
    //! \brief  transform Polyline with inTransformation
    virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
    type_detk get_type_detk() const;
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup geom
//! \class  Dtk_Line
//! \brief This is the Infinite Line Class.
//! 0.0 parametrisation is first point or origin
//! 1.0 parametrisation is second point or vector norm
//! \SmartPtr{Dtk_LinePtr}
class Dtk_Line : public Dtk_Curve
{
protected:
     //! \brief Not defined here   
     struct Dtk_Handle;       
     //! \brief Handle   
     std::unique_ptr<Dtk_Handle> _Private;  
     //! \brief Entity Type
     enum { _typeID = DTK_TYPE_LINE }; 
     Dtk_Line();
     Dtk_Line(const Dtk_Line& inLineToCopy);
     Dtk_Line(Dtk_Line&& in) DTK_NOEXCEPT;
     Dtk_Line(const Dtk_pnt &inOrigin, const Dtk_dir &inDirection);
     Dtk_Line(const Dtk_pnt &inPnt1, const Dtk_pnt &inPnt2);
    inline virtual Dtk_Object* Clone() { return new Dtk_Line(*this); }
     //! \BaseDestructor
     virtual ~Dtk_Line();
private:
     //! \brief  smart pointer
     friend class Dtk_SmartPtr<Dtk_Line>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Line * DtkDynamicCast(Dtk_Object * inObjectToCast);
 
     //! \CreateCopy{in}
     static Dtk_LinePtr Create(const Dtk_Line& in);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_LinePtr Create(const Dtk_pnt &inPnt1, const Dtk_pnt &inPnt2);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_LinePtr Create(const Dtk_pnt &inOrigin, const Dtk_dir &inDirection);
 
     //methods
     //! \brief  return origin of line
     Dtk_pnt GetOrigin() const;
     //! \brief  return direction of line
     Dtk_dir GetDirection() const;
 
     virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
     virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const; 
     virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute dir on U parameter
     virtual Dtk_ErrorStatus ComputeUDir(const Dtk_Double64& inU,Dtk_dir& outDir) const; 
     virtual Dtk_pnt ComputeStartPoint() const; 
     virtual Dtk_pnt ComputeEndPoint() const; 
     virtual void Reverse(); 
     virtual Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax,Dtk_bool inMorePrecise = 0);
 
 
     //! \brief Get Curve Parametrisation 
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
 
     //! \brief  transform Line with inTransformation
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     //! \brief Normalize Curve
     virtual void Normalize(); 
 
     type_detk get_type_detk() const;
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, int inUdiff,Dtk_dir &outdir,int exttype) const;
};
 
//! \ingroup geom
//! \class  Dtk_Conic
//! \brief This is the Conic Class.
//! \SmartPtr{Dtk_ConicPtr}
//!
class Dtk_Conic : public Dtk_Curve
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_CONIC }; 
    Dtk_Conic();
    Dtk_Conic(const Dtk_Conic& in);
     Dtk_Conic(Dtk_Conic&& in) DTK_NOEXCEPT;
    virtual Dtk_Object* Clone() = 0;
    virtual ~Dtk_Conic();
private:
    Dtk_ErrorStatus _SetCenterPoint(const Dtk_pnt& inCenterPoint);
    Dtk_ErrorStatus _SetCenterPoint(const Dtk_Double64& inXCenterPoint,const Dtk_Double64& inYCenterPoint,const Dtk_Double64& inZCenterPoint);
    Dtk_ErrorStatus _SetNormalDirection(const Dtk_dir& inNormalDirection);
    Dtk_ErrorStatus _SetOriginDirection(const Dtk_dir& inOriginDirection);
 
    friend class Dtk_SmartPtr<Dtk_Conic>;
public:
 
     //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Conic * DtkDynamicCast(Dtk_Object * inObject);
 
    //methods
     //! \brief Get Center of Conic (inCenter on schema)
    const Dtk_pnt& GetCenterPoint() const;
 
     //! \brief Get Normal vector of Conic (inNormal on schema)
     const Dtk_dir& GetNormalDirection() const;
     const Dtk_dir& GetZDirection() const;
 
     //! \brief Get Origin of parametrisation of Conic (inXdir on schema)
     const Dtk_dir& GetOriginDirection() const;
     const Dtk_dir& GetXDirection() const;
 
     //! \brief Get Y direction of Conic
     Dtk_dir GetYDirection() const;
 
     //! \brief  Get Nurbs corresponding to conic (with trim)
    virtual Dtk_NurbsCurvePtr ToNurbs()const; 
 
     Dtk_ErrorStatus SetStartAngle(Dtk_Double64 inAngle);
 
     //! \brief  transform Conic
     virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     type_detk get_type_detk() const;
     
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \ingroup geom
//! \class  Dtk_Ellipse
//! \brief This is the ellipse and circle Class.
//! parametrisation :[ 0.0 - 2PI ] 0.0  is given by inXref or inOriginDirection
//! \image html geom_ellipse.png
//! \SmartPtr{Dtk_EllipsePtr}
//!
class Dtk_Ellipse : public Dtk_Conic
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_ELLIPSE }; 
     Dtk_Ellipse();
     Dtk_Ellipse(const Dtk_Ellipse& in);
     Dtk_Ellipse(Dtk_Ellipse&& in) DTK_NOEXCEPT;
     Dtk_Ellipse(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inMajorRadius,const Dtk_Double64& inMinorRadius);
    inline virtual Dtk_Object* Clone() { return new Dtk_Ellipse(*this); }
     virtual ~Dtk_Ellipse();
private:
    Dtk_ErrorStatus _SetRadius(const Dtk_Double64& inMajorRadius,const Dtk_Double64& inMinorRadius);
    Dtk_ErrorStatus _SetRadius(const Dtk_Double64& inRadius);
     friend class Dtk_SmartPtr<Dtk_Ellipse>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Ellipse * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \CreateCopy{in}
     static Dtk_EllipsePtr Create(const Dtk_Ellipse& in );
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_EllipsePtr Create(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inMajorRadius,const Dtk_Double64& inMinorRadius);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_EllipsePtr Create(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inRadius);
 
     //methods
     Dtk_bool IsCircle()const;
     Dtk_Double64 GetMajorRadius() const;
     Dtk_Double64 GetMinorRadius() const;
 
 
     //! \brief Get Curve Parametrisation 
     Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
    virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
   // virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
    virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute dir on U parameter
     virtual Dtk_ErrorStatus ComputeUDir(const Dtk_Double64& inU,Dtk_dir& outDir) const; 
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const ; 
     //! \brief Compute Bounding Box
     virtual Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax,Dtk_bool inMorePrecise = 0);
 
 
     virtual Dtk_pnt ComputeStartPoint() const; 
     virtual Dtk_pnt ComputeEndPoint() const; 
     virtual void Reverse(); 
 
     //! \brief  transform
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     type_detk get_type_detk() const;
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, int inUdiff,Dtk_dir &outdir,int exttype) const;
};
 
//! \SmartPtr{Dtk_ParabolaPtr}
class Dtk_Parabola : public Dtk_Conic
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_PARABOLA }; 
     Dtk_Parabola();
     Dtk_Parabola(const Dtk_Parabola& in);
     Dtk_Parabola(Dtk_Parabola&& in) DTK_NOEXCEPT;
     Dtk_Parabola(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inMajorRadius);
    inline virtual Dtk_Object* Clone() { return new Dtk_Parabola(*this); }
     virtual ~Dtk_Parabola();
private:
     Dtk_ErrorStatus _SetFocal(const Dtk_Double64& inFocal);
     friend class Dtk_SmartPtr<Dtk_Parabola>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Parabola * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \CreateCopy{in}
     static Dtk_ParabolaPtr Create(const Dtk_Parabola& in);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_ParabolaPtr Create(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inFocal);
 
     //methods
     Dtk_Double64 GetFocalDistance() const;
 
 
     //! \brief Get Curve Parametrisation 
     Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
     virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
     //virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
     virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const; 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 u, int inUdiff,Dtk_dir &outdir,int exttype) const;
 
     virtual Dtk_pnt ComputeStartPoint() const; 
     virtual Dtk_pnt ComputeEndPoint() const; 
     virtual void Reverse(); 
 
 
 
     //! \brief  transform
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     type_detk get_type_detk() const;
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
//! \SmartPtr{Dtk_HyperbolaPtr}
class Dtk_Hyperbola : public Dtk_Conic
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_HYPERBOLA }; 
     Dtk_Hyperbola();
     Dtk_Hyperbola(const Dtk_Hyperbola& in);
     Dtk_Hyperbola( Dtk_Hyperbola&& in) DTK_NOEXCEPT;
     Dtk_Hyperbola(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inSemiAxis,const Dtk_Double64& inSemiImageAxis);
    inline virtual Dtk_Object* Clone() { return new Dtk_Hyperbola(*this); }
     virtual ~Dtk_Hyperbola();
private:
     friend class Dtk_SmartPtr<Dtk_Hyperbola>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_Hyperbola * DtkDynamicCast(Dtk_Object * inObject);
 
     //! \CreateCopy{in}
     static Dtk_HyperbolaPtr Create(const Dtk_Hyperbola& in);
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_HyperbolaPtr Create(const Dtk_pnt& inCenter,const Dtk_dir& inNormal,const Dtk_dir& inXref,const Dtk_Double64& inSemiAxis,const Dtk_Double64& inSemiImageAxis);
 
     //methods
     Dtk_Double64 GetSemiAxis() const;
     Dtk_Double64 GetSemiImageAxis() const;
 
 
     //! \brief Get Curve Parametrisation 
     Dtk_ErrorStatus GetDomain(Dtk_Double64& outUmin,Dtk_Double64& outUmax) const;
     virtual Dtk_PolylinePtr ToPolyline(const int & inMinPoint,const Dtk_Double64& inTolerance)const ;
     //virtual Dtk_NurbsCurvePtr ToNurbs()const ; 
     virtual Dtk_ErrorStatus ComputeUPoint(const Dtk_Double64& inU,Dtk_pnt& outPoint)const ; 
     //! \brief Compute U parameter from point
     virtual Dtk_ErrorStatus ComputeParameter(const Dtk_pnt& inPoint,Dtk_Double64& outU)const ; 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 u, int inUdiff,Dtk_dir &outdir,int exttype) const;
 
     virtual Dtk_pnt ComputeStartPoint() const; 
     virtual Dtk_pnt ComputeEndPoint() const; 
     virtual void Reverse(); 
 
     Dtk_NurbsCurvePtr ToNurbs()const;
 
     //! \brief  transform
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     type_detk get_type_detk() const;
 
     virtual Dtk_ErrorStatus _Store(void*);
     virtual Dtk_Size_t GetSize() const;
};
 
/*************************************** END  CURVES **********************************/
/***************************************  SURFACES **********************************/
//! \ingroup geom
//! \class Dtk_Surface 
//! \brief Dtk_Surface is a geometrical entity representing a surface. 
//!  Some type of surface are unlimited such as plane, conical, cylindrical, extrusion surface.
//! It is an abstract class that cannot be instancied.  \n
//! It has several utility methods :  \n
//! - GetDomain  allow you to get the whole definition domain for the surface.
//! - SetTrimDomain/GetTrimDomain  allow you to specify/get the used domain for the surface.
//! - ToNurbs convert the surface into nurbs surface.
 
class Dtk_Surface : public Dtk_Entity
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_SURFACE }; 
    Dtk_Surface();
    Dtk_Surface(const Dtk_Surface& s);
    Dtk_Surface( Dtk_Surface&& s) DTK_NOEXCEPT;
    virtual Dtk_Object* Clone() = 0;
    virtual ~Dtk_Surface();
private:
    friend class Dtk_SmartPtr<Dtk_Surface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_Surface * DtkDynamicCast(Dtk_Object * s);
 
     //! \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]
    virtual Dtk_ErrorStatus SetTrimUVBox(Dtk_Double64 inTrimValues[]);
     //! \brief Set Surface Parametrisation  : Umin = inDomain[0]  Umax = inDomain[1] Vmin = inDomain[2]  Vmax = inDomain[3]
    //virtual Dtk_ErrorStatus SetDomain(Dtk_Double64 inDomain[]);
 
     //! \brief Compute Bounding Box
    Dtk_ErrorStatus ComputeBoundingBox(Dtk_pnt& outMin, Dtk_pnt& outMax) const;
     //! \brief Compute Normal on UV point
     virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     //! \brief Compute 3D point
     virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const = 0;
     //! \brief Compute 3D first derivative on UV point according to UV derivative
     Dtk_ErrorStatus ComputeUVto3DFirstDerivative( const Dtk_Double64& inUValue, const Dtk_Double64& inVValue, const Dtk_dir& inUVFirstDerivative, Dtk_dir &out3DFirstDerivative ) const;
     //! \brief Compute 3D second derivative on UV point according to UV derivatives
     Dtk_ErrorStatus ComputeUVto3DSecondDerivative( const Dtk_Double64& inUValue, const Dtk_Double64& inVValue, const Dtk_dir& inUVFirstDerivative, const Dtk_dir& inUVSecondDerivative, Dtk_dir &out3DSecondDerivative ) const;
     //! \brief Return DTK_TRUE If Periodic following U parameter
    virtual Dtk_bool IsUPeriodic() const;
     //! \brief Return DTK_TRUE If Periodic following V parameter
    virtual Dtk_bool IsVPeriodic() const;
     //! \brief Return DTK_TRUE if Surface Is trimmed by parameter value
     Dtk_bool IsTrimmed()const;
 
    //virtual methods
     //! \brief Convert a surface into a Nurbs, keeping the parametrisation of the initial surface
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL)const =0;
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const=0;
     friend void PDtk_StoreDataSurface(void*,Dtk_SurfacePtr&);
     
     //Internal use only
     void DeleteCorrespondingNurbs();
     Dtk_bool _HasInternalNurbs() const;
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int extendtype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int extendtype) const;
};
 
//! \ingroup geom
//! \class Dtk_NurbsSurface 
//! \brief This is the Nurbs Surface Class.
//! \SmartPtr{Dtk_NurbsSurfacePtr}
//!
class Dtk_NurbsSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_NURBS_SURFACE }; 
    Dtk_NurbsSurface();
    Dtk_NurbsSurface(const Dtk_NurbsSurface& in);
    Dtk_NurbsSurface( Dtk_NurbsSurface&& in) DTK_NOEXCEPT;
    Dtk_NurbsSurface(const Dtk_UInt32& inUDegree,const Dtk_UInt32& inVDegree,const Dtk_tab<Dtk_Double64> &inUKnots,const Dtk_tab<Dtk_Double64> &inVKnots,const Dtk_tab<Dtk_pnt> &inControlPoints,
          const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>(),type_detk inSurfaceType = DTK_TYPE_NURBS_SURFACE);
    Dtk_NurbsSurface(const Dtk_UInt32& inUDegree,const Dtk_UInt32& inVDegree,const Dtk_tab<Dtk_Double64> &inUKnotsValues,const Dtk_tab<Dtk_Double64> &inVKnotsValues,
          const Dtk_tab<Dtk_UChar8> &inUKnotsMultiplicities,const Dtk_tab<Dtk_UChar8> &inVKnotsMultiplicities,const Dtk_tab<Dtk_tab<Dtk_pnt> > &inControlPoints,
          const Dtk_tab<Dtk_tab<Dtk_Double64> > &inWeights=Dtk_tab<Dtk_tab<Dtk_Double64> >(),type_detk inSurfaceType = DTK_TYPE_NURBS_SURFACE);
     Dtk_NurbsSurface(const Dtk_tab<Dtk_SurfacePtr> &inSurfacesToMerge, Dtk_Double64 stichtol /*= DTK_TOLERANCE */ );
 
    inline virtual Dtk_Object* Clone() { return new Dtk_NurbsSurface(*this); }
    virtual ~Dtk_NurbsSurface();
private:
     void _SetPointsArray(const Dtk_tab< Dtk_tab<Dtk_pnt> > &inPoints);
     void _SetPointsArray(Dtk_pnt **inPoints,const Dtk_Size_t &inUSize,const Dtk_Size_t &inVSize);
     void _SetWeightsArray(const Dtk_tab< Dtk_tab<Dtk_Double64> > &inWeights) ;
     void _SetWeightsArray(Dtk_Double64 ** inWeights,const Dtk_Size_t &inUSize,const Dtk_Size_t &inVSize) ;
    void _SetNodalVectorU(const Dtk_tab<Dtk_Double64> &inNodalVector);
     void _SetNodalVectorU(const Dtk_Double64 * inNodalVector,const Dtk_Size_t &inSize);
     void _SetNodalVectorV(const Dtk_tab<Dtk_Double64> &inNodalVector);
     void _SetNodalVectorV(const Dtk_Double64 * inNodalVector,const Dtk_Size_t &inSize);
    /*void _AddUKnotValue(const Dtk_UInt32& inKnotMultiplicity,const Dtk_Double64& inKnotValue);
    void _AddVKnotValue(const Dtk_UInt32& inKnotMultiplicity,const Dtk_Double64& inKnotValue);*/
 
     Dtk_ErrorStatus _ComputeAnyDerivative_exotic(const Dtk_Double64 &inUvalue, const Dtk_Double64 &inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative_exotic(const Dtk_Double64 &inUalue, const Dtk_Double64 &inValue, int ndu,int ndv,int nduvmax,Dtk_dir* outdirs,int exttype) const;
 
     inline Dtk_Double64*Pdtk_unpacknodal( int unbk, int cnbk, Dtk_UChar8* multi, Dtk_Double64* compknots ) const;
 
    friend class Dtk_SmartPtr<Dtk_NurbsSurface>;
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivativeExtended(Dtk_Double64 inUalue, Dtk_Double64 inValue, int ndu,int ndv,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivativeExtendedOld( Dtk_Double64 inUalue, Dtk_Double64 inValue, int ndu, int ndv, int nduvmax, Dtk_dir* outdirs, int exttype ) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivativeExtended(Dtk_Double64 inUalue, Dtk_Double64 inValue, int ndu,int ndv,int nduvmax,Dtk_dir* outdirs,int exttype) const;
public:
     Dtk_ErrorStatus _KnotInsertion(const Dtk_Double64 &inParameter,const Dtk_Size_t &inOccurence,const Dtk_bool &inUSplit,Dtk_Double64 inTolerance=DTK_TOLERANCE);
     int _KnotRemoval(const Dtk_Double64 &inParameter,const int &inOccurence,const Dtk_bool &inUSplit,const Dtk_Double64 &inTolerance);
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_NurbsSurface * DtkDynamicCast(Dtk_Object * s);
 
     //! \CreateCopy{in}
    static Dtk_NurbsSurfacePtr Create(const Dtk_NurbsSurface& in);
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inControlPoints Control points must be in order [ u0v0, u0v1, u0v2, ..., u1v0, u1v1, u1v2, ..., ..., uNv0, uNv1, uNv2, ..., uNvM ].
     static Dtk_NurbsSurfacePtr Create(const Dtk_UInt32& inUDegree,const Dtk_UInt32& inVDegree,const Dtk_tab<Dtk_Double64> &inUKnots,
          const Dtk_tab<Dtk_Double64> &inVKnots,const Dtk_tab<Dtk_pnt> &inControlPoints,const Dtk_tab<Dtk_Double64> &inWeights=Dtk_tab<Dtk_Double64>(),type_detk inSurfaceType = DTK_TYPE_NURBS_SURFACE);
     //! \brief Calls full featured constructor to allocate a new object.
     //! \param inControlPoints Control points must be in order [ [u0v0, u0v1, u0v2, ...], [u1v0, u1v1, u1v2, ...], ..., [uNv0, uNv1, uNv2, ...] ].
     static Dtk_NurbsSurfacePtr Create(const Dtk_UInt32& inUDegree,const Dtk_UInt32& inVDegree,const Dtk_tab<Dtk_Double64> &inUKnotsValues,
          const Dtk_tab<Dtk_Double64> &inVKnotsValues,const Dtk_tab<Dtk_UChar8> &inUKnotsMultiplicities,const Dtk_tab<Dtk_UChar8> &inVKnotsMultiplicities,const Dtk_tab<Dtk_tab<Dtk_pnt> > &inControlPoints,
          const Dtk_tab<Dtk_tab<Dtk_Double64> > &inWeights=Dtk_tab<Dtk_tab<Dtk_Double64> >(),type_detk inSurfaceType = DTK_TYPE_NURBS_SURFACE );
     //! \brief Calls full featured constructor to allocate a new object.
     static Dtk_NurbsSurfacePtr Create(const Dtk_tab<Dtk_SurfacePtr> &inSurfacesToMerge, Dtk_Double64 stichtol = DTK_TOLERANCE );
 
 
    //methods
    Dtk_UInt32 GetUDegree() const;
    Dtk_Size_t GetNumKnotsU() const;
    Dtk_UInt32 GetVDegree() const;
    Dtk_Size_t GetNumKnotsV() const;
    Dtk_Double64 GetUKnotValue(const Dtk_Size_t& inIndex) const;
    Dtk_UInt32 GetUKnotMultiplicity(const Dtk_Size_t& inIndex ) const;
    Dtk_Double64 GetVKnotValue(const Dtk_Size_t& inIndex ) const;
    Dtk_UInt32 GetVKnotMultiplicity(const Dtk_Size_t& inIndex ) const;
    Dtk_Size_t GetNumPointsU() const;
    Dtk_Size_t GetNumPointsV() const;
 
    const Dtk_pnt& Point(const Dtk_Size_t& inUIndex , const Dtk_Size_t& inVIndex) const;
    Dtk_pnt& Point(const Dtk_Size_t& inUIndex , const Dtk_Size_t& inVIndex);
    Dtk_Double64 GetWeight(const Dtk_Size_t& inUIndex , const Dtk_Size_t& inVIndex) const;
    Dtk_bool IsRationnal() const;
    Dtk_bool IsBezier() const;
    Dtk_bool IsUniform() const;
    Dtk_bool IsPlane() const;
 
     //! \brief  return DTK_TRUE if nurbs is periodic in U
     virtual Dtk_bool IsUPeriodic() const;
     //! \brief  return DTK_TRUE if nurbs is periodic in V
     virtual Dtk_bool IsVPeriodic() const;
 
      void SetIsUPeriodic(Dtk_bool inPeriodicFlag);
      void SetIsVPeriodic(Dtk_bool inPeriodicFlag);
      void SetTypeBeforeConversion(type_detk type);
 
 
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
 
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_ErrorStatus ComputeUDerivative(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outdir) const;
     virtual Dtk_ErrorStatus ComputeVDerivative(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outdir) const;
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
     virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
    virtual Dtk_ErrorStatus Reparam(Dtk_Double64 inDomain[]);
    type_detk get_type_detk() const;
    type_detk GetTypeBeforeConversion() const;
    virtual Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
 
     Dtk_ErrorStatus SplitAt(const Dtk_Double64 &inParameter,const Dtk_bool &inUSplit,const Dtk_bool &inKeepLeft,Dtk_NurbsSurfacePtr &outOtherPart,Dtk_Double64 inTolerance=DTK_TOLERANCE);
     Dtk_ErrorStatus Split(Dtk_Double64 inTrimDom[4],Dtk_Double64 inTolerance=DTK_TOLERANCE);
     Dtk_ErrorStatus ReduceDegree( const Dtk_UInt32& inTargetUDegree, const Dtk_UInt32& inTargetVDegree );
     Dtk_NurbsSurfacePtr ForceG1Continuity (Dtk_Double64 tolerance_to_remove = 0.0005) const;
 
     Dtk_Double64 *GetUnpackedUKnot() const;
     Dtk_Double64 *GetUnpackedVKnot() const;
};
 
//! \ingroup geom
//! \class Dtk_PlaneSurface 
//! \brief This is the Plane Surface Class.
//! \brief U parametrisation : [-infini - +infini] : 0 is inOrigin and unit vector is inUDirection
//! \brief V parametrisation : [-infini - +infini] : 0 is inOrigin and unit vector is inVDirection
//! \image html geom_plane.png
//! \SmartPtr{Dtk_PlaneSurfacePtr}
class Dtk_PlaneSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
    std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_PLANE}; 
    Dtk_PlaneSurface();
    Dtk_PlaneSurface(const Dtk_PlaneSurface& s);
    Dtk_PlaneSurface( Dtk_PlaneSurface&& s) DTK_NOEXCEPT;
    Dtk_PlaneSurface(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal,const Dtk_dir& inUDirection,const Dtk_dir& inVDirection);
    inline virtual Dtk_Object* Clone() { return new Dtk_PlaneSurface(*this); }
 
    virtual ~Dtk_PlaneSurface();
private:
    friend class Dtk_SmartPtr<Dtk_PlaneSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_PlaneSurface * DtkDynamicCast(Dtk_Object * s);
 
     //! \brief Create an infinite plane surface
     //! \param [in] inOrigin : Origin of plane ( origin of Uparametrisation and Vparametrisation )
     //! \param [in] inNormal : Plane Normal or Zdir
     //! \param [in] inUDirection : UDirection (origin of Uparametrisation) or Xdir
     //! \param [in] inVDirection : optionnal VDirection (origin of Vparametrisation) or Ydir
     //! \return Dtk_PlaneSurfacePtr created surface  
    static Dtk_PlaneSurfacePtr Create(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal,const Dtk_dir& inUDirection,const Dtk_dir& inVDirection=Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_PlaneSurfacePtr Create(const Dtk_PlaneSurface& in);
 
    //methods
    Dtk_pnt GetOrigin()const;
    Dtk_dir GetNormal()const;
    Dtk_dir GetUDirection()const;
    Dtk_dir GetVDirection()const;
    Dtk_dir GetXDirection() const;
    Dtk_dir GetYDirection() const;
    Dtk_dir GetZDirection() const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
      virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     Dtk_ErrorStatus Normalize();
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_RevolutionSurface 
//! \brief This is the Revolution Surface Class.
//! \deprecated Use Dtk_StandardRevolutionSurface instead.
//! U parametrisation : [0.0 - 2PI]  0.0 is given by inUDirection or inXdir or inOriginDirection
//! V parametrisation : revolved curve parametrisation
//! \SmartPtr{Dtk_RevolutionSurfacePtr}
//!
class Dtk_RevolutionSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_REVOLUTION_SURFACE}; 
    Dtk_RevolutionSurface();
    Dtk_RevolutionSurface( const Dtk_RevolutionSurface& );
    Dtk_RevolutionSurface( Dtk_RevolutionSurface&& ) DTK_NOEXCEPT;
    Dtk_RevolutionSurface(const Dtk_CurvePtr& inRevolvedCurve,const Dtk_pnt& inAxisposition,const Dtk_dir& inRevolutionAxis,const Dtk_dir& inUDirection,const Dtk_dir&inYDir);
    inline virtual Dtk_Object* Clone() { return new Dtk_RevolutionSurface(*this); }
    virtual ~Dtk_RevolutionSurface();
private:
    friend class Dtk_SmartPtr<Dtk_RevolutionSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_RevolutionSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief OBSOLETE Create Dtk_RevolutionSurface 
     //! \deprecated Create Dtk_StandardRevolutionSurface instead.
     //! \param [in] inRevolvedCurve : Curve to be revolved
     //! \param [in] inAxisposition : Revolution Axis Position 
     //! \param [in] inRevolutionAxis : Revolution Axis or Zdir
     //! \param [in] inUDirection : UDirection (origin of Uparametrisation) or Xdir
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_RevolutionSurfacePtr created surface 
     SetAsDeprecated( "2026.3", "Use Dtk_StandardRevolutionSurfacePtr" )
    static Dtk_RevolutionSurfacePtr Create(const Dtk_CurvePtr& inRevolvedCurve,const Dtk_pnt& inAxisposition,const Dtk_dir& inRevolutionAxis,const Dtk_dir& inUDirection,const Dtk_dir&inYDir= Dtk_dir());
     //! \CreateCopy{in}
     SetAsDeprecated( "2026.3", "Use Dtk_StandardRevolutionSurfacePtr" )
     static Dtk_RevolutionSurfacePtr Create(const Dtk_RevolutionSurface& in);
 
    //methods
     //! \brief GetRevolvedCurve 
     //! \return Curve to be revolved
    Dtk_CurvePtr GetRevolvedCurve() const;
     //! \brief GetRevolutionAxis 
     //! \return revolution Axis (same as GetZDirection )
    const Dtk_dir& GetRevolutionAxis() const;
     //! \brief Get origin  
     //! \return Center point of revolution
     const Dtk_pnt& GetAxisPosition() const;
     //! \brief Give U origin for parametrisation
     //! \return Dtk_dir for U start 
     const Dtk_dir& GetXDirection()const;
     //! \brief Give Y Direction (Axis Placement can be indirect )
     //! \return Dtk_dir 
     Dtk_dir GetYDirection()const;
     //! \brief GetZDirection 
     //! \return revolution Axis (same as GetRevolutionAxis )
     const Dtk_dir& GetZDirection()const;
     //! \brief Get Radius at origin
     //! \return GetRadius
    Dtk_Double64 GetRadius()const;
 
     // Obsolete Function
     Dtk_ErrorStatus SetStartAngle(Dtk_Double64 inAngle);
     
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     //virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     Dtk_ErrorStatus SetTrimUVBox(Dtk_Double64 inDomain[]);
     Dtk_ErrorStatus Normalize();
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_StandardRevolutionSurface 
//! \brief This is the Revolution Surface Class.
//! \brief U parametrisation : revolved curve parametrisation
//! \brief V parametrisation : [0.0 - 2PI] 0.0 is given by inVDirection
//! \image html geom_strevolution.png
//! \SmartPtr{Dtk_StandardRevolutionSurfacePtr}
//!
class Dtk_StandardRevolutionSurface : public Dtk_Surface
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_STANDARD_REVOLUTION_SURFACE}; 
     Dtk_StandardRevolutionSurface();
     Dtk_StandardRevolutionSurface( const Dtk_StandardRevolutionSurface& );
     Dtk_StandardRevolutionSurface( Dtk_StandardRevolutionSurface&& ) DTK_NOEXCEPT;
     Dtk_StandardRevolutionSurface(const Dtk_CurvePtr& inRevolvedCurve,const Dtk_pnt& inAxisposition,const Dtk_dir& inRevolutionAxis,const Dtk_dir& inVDirection,const Dtk_dir&inYDir);
     inline virtual Dtk_Object* Clone() { return new Dtk_StandardRevolutionSurface(*this); }
     virtual ~Dtk_StandardRevolutionSurface();
private:
     friend class Dtk_SmartPtr<Dtk_StandardRevolutionSurface>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_StandardRevolutionSurface * DtkDynamicCast(Dtk_Object * s);
 
     //constructors
     //! \brief Create Dtk_StandardRevolutionSurface 
     //! \param [in] inRevolvedCurve : Curve to be revolved
     //! \param [in] inAxisposition : Revolution Axis Position 
     //! \param [in] inRevolutionAxis : Revolution Axis or Zdir
     //! \param [in] inVDirection : inVDirection (origin of Vparametrisation) or Xdir
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_StandardRevolutionSurfacePtr created surface  
     static Dtk_StandardRevolutionSurfacePtr Create(const Dtk_CurvePtr& inRevolvedCurve,const Dtk_pnt& inAxisposition,const Dtk_dir& inRevolutionAxis,const Dtk_dir& inVDirection,const Dtk_dir&inYDir= Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_StandardRevolutionSurfacePtr Create(const Dtk_StandardRevolutionSurface& in);
 
     //methods
     //! \brief GetRevolvedCurve 
     //! \return Curve to be revolved
     Dtk_CurvePtr GetRevolvedCurve() const;
     //! \brief GetRevolutionAxis 
     //! \return revolution Axis (same as GetZDirection )
     const Dtk_dir& GetRevolutionAxis() const;
     //! \brief Get origin  
     //! \return Center point of revolution
     const Dtk_pnt& GetAxisPosition() const;
     //! \brief Give V origin for parametrisation
     //! \return Dtk_dir for V start 
     const Dtk_dir& GetXDirection()const;
     //! \brief Give Y Direction (Axis Placement can be indirect )
     //! \return Dtk_dir 
     Dtk_dir GetYDirection()const;
     //! \brief GetZDirection 
     //! \return revolution Axis (same as GetRevolutionAxis )
     const Dtk_dir& GetZDirection()const;
     //! \brief Get Radius at origin
     //! \return GetRadius
     Dtk_Double64 GetRadius()const;
 
     // Obsolete Function
     Dtk_ErrorStatus SetStartAngle(Dtk_Double64 inAngle);
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
     virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
     virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     //virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
     type_detk get_type_detk() const;
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     Dtk_ErrorStatus SetTrimUVBox(Dtk_Double64 inDomain[]);
     Dtk_ErrorStatus Normalize();
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_LinearExtrusionSurface 
//! \brief This is the Linear Extrusion Surface Class.
//! \brief U parametrisation : Curve to be extruded
//! \brief V parametrisation : [-infini - +infini] 0 is given by Curve position and unit vector is extrusion axis 
//! \image html geom_extrusion.png
//! \SmartPtr{Dtk_LinearExtrusionSurfacePtr}
//!
class Dtk_LinearExtrusionSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_LINEAR_EXTRUSION_SURFACE}; 
    Dtk_LinearExtrusionSurface();
    Dtk_LinearExtrusionSurface( const Dtk_LinearExtrusionSurface& );
    Dtk_LinearExtrusionSurface( Dtk_LinearExtrusionSurface&& ) DTK_NOEXCEPT;
    Dtk_LinearExtrusionSurface(const Dtk_CurvePtr& inExtrudedCurve,const Dtk_dir& inExtrusionAxis);
    inline virtual Dtk_Object* Clone() { return new Dtk_LinearExtrusionSurface(*this); }
 
    virtual ~Dtk_LinearExtrusionSurface();
private:
    friend class Dtk_SmartPtr<Dtk_LinearExtrusionSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_LinearExtrusionSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief Create an infinite Dtk_LinearExtrusionSurface from a curve and a extrusion vector two curves
     //! \param [in] inExtrudedCurve : Curve to be extruded
     //! \param [in] inExtrusionAxis : Extrusion Axis
     //! \return Dtk_LinearExtrusionSurfacePtr created surface  
    static Dtk_LinearExtrusionSurfacePtr Create(const Dtk_CurvePtr& inExtrudedCurve,const Dtk_dir& inExtrusionAxis);
     //! \CreateCopy{in}
    static Dtk_LinearExtrusionSurfacePtr Create(const Dtk_LinearExtrusionSurface& in);
 
    //methods
    Dtk_CurvePtr GetExtrudedCurve() const;
    const Dtk_dir& GetExtrusionAxis() const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     //virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     Dtk_ErrorStatus Normalize();
    virtual Dtk_bool IsUPeriodic() const;
    virtual Dtk_bool IsVPeriodic() const;
 
     Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_RuledSurface 
//! \brief This is the Ruled Surface Class.
//! \brief U Parametrisation  is given by curve parametrisation 
//! \brief V Parametrisation [0.0 - 1.0 ]  0 is first curve and 1 is second curve
//! \SmartPtr{Dtk_RuledSurfacePtr}
class Dtk_RuledSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_RULED_SURFACE}; 
    Dtk_RuledSurface();
    Dtk_RuledSurface(const Dtk_RuledSurface& s);
    Dtk_RuledSurface(Dtk_RuledSurface&& s) DTK_NOEXCEPT;
    Dtk_RuledSurface(const Dtk_CurvePtr& inFirstCurve,const Dtk_CurvePtr& inSecondCurve);
    inline virtual Dtk_Object* Clone() { return new Dtk_RuledSurface(*this); }
 
    virtual ~Dtk_RuledSurface();
private:
    friend class Dtk_SmartPtr<Dtk_RuledSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_RuledSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief Create Dtk_RuledSurface between two curves
     //! \param [in] inFirstCurve : First Curve 
     //! \param [in] inSecondCurve : Second Curve
     //! \return Dtk_RuledSurfacePtr created surface  
    static Dtk_RuledSurfacePtr Create(const Dtk_CurvePtr& inFirstCurve,const Dtk_CurvePtr& inSecondCurve);    
     //! \CreateCopy{in}
    static Dtk_RuledSurfacePtr Create(const Dtk_RuledSurface& in);
 
    //methods
    Dtk_CurvePtr GetFirstCurve() const;
    Dtk_CurvePtr GetSecondCurve() const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
     Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_CylindricalSurface 
//! \brief This is the Cylindrical Surface Class.
//! \brief U parametrisation : [0.0 - 2PI]  0.0 is given by inUDirection or inXdir or inOriginDirection
//! \brief V parametrisation : [-infini - +infini] as revolved curve is a line
//! \image html geom_cylindrical.png
//! \SmartPtr{Dtk_CylindricalSurfacePtr}
//!
class Dtk_CylindricalSurface : public Dtk_RevolutionSurface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_CYLINDRICAL_SURFACE    }; 
    Dtk_CylindricalSurface();
    Dtk_CylindricalSurface(const Dtk_CylindricalSurface& s);
    Dtk_CylindricalSurface( Dtk_CylindricalSurface&& s) DTK_NOEXCEPT;
    Dtk_CylindricalSurface(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inUDirection, const Dtk_dir& inYDirection, const Dtk_Double64& inRadius);
    inline virtual Dtk_Object* Clone() { return new Dtk_CylindricalSurface(*this); }
    virtual ~Dtk_CylindricalSurface();
private:
    friend class Dtk_SmartPtr<Dtk_CylindricalSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_CylindricalSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief Create an infinite cylinder
     //! \param [in] inOrigin : Cylinder origin
     //! \param [in] inNormal : Cylinder Axis or Zdir
     //! \param [in] inUDirection : UDirection ( origin of Uparametrisation) or Xdir
     //! \param [in] inRadius : Cylinder Radius
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_CylindricalSurfacePtr created surface  
     static Dtk_CylindricalSurfacePtr Create(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inUDirection,const Dtk_Double64& inRadius, const Dtk_dir& inYDirection=Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_CylindricalSurfacePtr Create(const Dtk_CylindricalSurface& in);
 
    //methods
    Dtk_Double64 GetRadius()const;
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
      virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
     Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
};
 
 
//! \ingroup geom
//! \class Dtk_ConicalSurface 
//! \brief This is the Conical Surface Class.
//! \brief U parametrisation : [0.0 - 2PI]  0.0 is given by inUDirection or inXdir or inOriginDirection
//! \brief V parametrisation : [-infini - +infini] as revolved curve is a line
//! \image html geom_conical.png
//! \SmartPtr{Dtk_ConicalSurfacePtr}
//!
class Dtk_ConicalSurface : public Dtk_RevolutionSurface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_CONICAL_SURFACE    }; 
    Dtk_ConicalSurface();
    Dtk_ConicalSurface(const Dtk_ConicalSurface& s);
    Dtk_ConicalSurface( Dtk_ConicalSurface&& s) DTK_NOEXCEPT;
     Dtk_ConicalSurface(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inYDirection, const Dtk_dir& inUDirection,const Dtk_Double64& inRadius,const Dtk_Double64& inAngle);
    inline virtual Dtk_Object* Clone() { return new Dtk_ConicalSurface(*this); }
 
    virtual ~Dtk_ConicalSurface();
private:
    friend class Dtk_SmartPtr<Dtk_ConicalSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_ConicalSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief  Create an infinite Cone
     //! \param [in] inOrigin : Cone origin
     //! \param [in] inNormal : Cone Axis or Zdir
     //! \param [in] inUDirection : UDirection ( origin of Uparametrisation) or Xdir
     //! \param [in] inFirstRadius : Cone Radius at origin
     //! \param [in] inAngle : semi_angle with Axis
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_ConicalSurfacePtr created surface  
     static Dtk_ConicalSurfacePtr Create(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inUDirection,const Dtk_Double64& inFirstRadius,const Dtk_Double64& inAngle, const Dtk_dir& inYDir=Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_ConicalSurfacePtr Create(const Dtk_ConicalSurface& in);
 
    //methods
    Dtk_Double64 GetRadius()const;
    Dtk_Double64 GetSemiAngle()const;
 
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
};
//! \ingroup geom
//! \class Dtk_ToroidalSurface 
//! \brief This is the Toroidal Surface Class.
//! \brief U parametrisation : [0.0 - 2PI]  0.0 is given by inUDirection or inXdir or inOriginDirection
//! \brief V parametrisation : [0.0 - 2PI] as revolved curve is a circle
//! \image html geom_toroidal.png
//! \SmartPtr{Dtk_ToroidalSurfacePtr}
//!
class Dtk_ToroidalSurface : public Dtk_RevolutionSurface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_TOROIDAL_SURFACE    }; 
     Dtk_ToroidalSurface();
     Dtk_ToroidalSurface( const Dtk_ToroidalSurface& );
     Dtk_ToroidalSurface( Dtk_ToroidalSurface&& ) DTK_NOEXCEPT;
    Dtk_ToroidalSurface(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal,const Dtk_dir& inYDir, const Dtk_dir& inUDirection,const Dtk_Double64& inMajorRadius,const Dtk_Double64& inMinorRadius);
    inline virtual Dtk_Object* Clone() { return new Dtk_ToroidalSurface(*this); }
 
    virtual ~Dtk_ToroidalSurface();
private:
    friend class Dtk_SmartPtr<Dtk_ToroidalSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_ToroidalSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief Create Dtk_ToroidalSurface 
     //! \param [in] inOrigin : Toroidal origin
     //! \param [in] inNormal : Toroidal Axis or Zdir
     //! \param [in] inUDirection : UDirection ( origin of Uparametrisation) or Xdir
     //! \param [in] inMajorRadius : Toroidal Major Radius
     //! \param [in] inMinorRadius : Toroidal Minor Radius
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_ToroidalSurfacePtr created surface  
    static Dtk_ToroidalSurfacePtr Create(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inUDirection,const Dtk_Double64& inMajorRadius,const Dtk_Double64& inMinorRadius, const Dtk_dir& inYDir=Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_ToroidalSurfacePtr Create(const Dtk_ToroidalSurface& in);
 
    //methods
    Dtk_Double64 GetMajorRadius()const;
    Dtk_Double64 GetMinorRadius()const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
      virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
   virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     virtual Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;    
     virtual Dtk_bool IsUPeriodic() const;
     virtual Dtk_bool IsVPeriodic() const;
};
 
//! \ingroup geom
//! \class Dtk_SphericalSurface 
//! \brief This is the Spherical Surface Class.
//! \brief U parametrisation : [0.0 - 2PI]  0.0 is given by inUDirection or inXdir or inOriginDirection
//! \brief V parametrisation : [-Pi/2 - +Pi/2] as revolved curve is a trimmed circle
//! \image html geom_spherical.png
//! \SmartPtr{Dtk_SphericalSurfacePtr}
//!
class Dtk_SphericalSurface : public Dtk_RevolutionSurface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_SPHERICAL_SURFACE    }; 
    Dtk_SphericalSurface();
    Dtk_SphericalSurface( const Dtk_SphericalSurface& );
    Dtk_SphericalSurface( Dtk_SphericalSurface&& ) DTK_NOEXCEPT;
    Dtk_SphericalSurface(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inYDir, const Dtk_dir& inUDirection,const Dtk_Double64& inRadius);
    inline virtual Dtk_Object* Clone() { return new Dtk_SphericalSurface(*this); }
 
    virtual ~Dtk_SphericalSurface();
private:
    friend class Dtk_SmartPtr<Dtk_SphericalSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_SphericalSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors
     //! \brief Create Dtk_SphericalSurface 
     //! \param [in] inOrigin : Spherical origin
     //! \param [in] inNormal : Spherical Axis or Zdir
     //! \param [in] inUDirection : UDirection ( origin of Uparametrisation) or Xdir
     //! \param [in] inRadius : Spherical Radius
     //! \param [in] inYDir  : Optional Ydir
     //! \return Dtk_SphericalSurfacePtr created surface  
    static Dtk_SphericalSurfacePtr Create(const Dtk_pnt& inOrigin,const Dtk_dir& inNormal, const Dtk_dir& inUDirection,const Dtk_Double64& inRadius, const Dtk_dir& inYDir=Dtk_dir());
     //! \CreateCopy{in}
     static Dtk_SphericalSurfacePtr Create(const Dtk_SphericalSurface& in);
 
    //methods
    Dtk_Double64 GetRadius()const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
      virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const ;
   virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
     Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;    
     //Dtk_ErrorStatus SetDomain(Dtk_Double64 inDomain[]);
     //! \brief Return DTK_TRUE If Periodic following U parameter
     virtual Dtk_bool IsUPeriodic() const;
     //! \brief Return DTK_TRUE If Periodic following V parameter
     virtual Dtk_bool IsVPeriodic() const;
};
 
//! \ingroup geom
//! \class Dtk_OffsetSurface 
//! \brief This is the Offset Surface Class.
//! \brief U parametrisation : like basis surface
//! \brief V parametrisation : like basis surface
//! \image html geom_offset.png
//! \SmartPtr{Dtk_OffsetSurfacePtr}
//!
class Dtk_OffsetSurface : public Dtk_Surface
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_OFFSET_SURFACE    }; 
     Dtk_OffsetSurface();
     Dtk_OffsetSurface(const Dtk_OffsetSurface& );
     Dtk_OffsetSurface( Dtk_OffsetSurface&& ) DTK_NOEXCEPT;
     Dtk_OffsetSurface(const Dtk_SurfacePtr &inSurf, const Dtk_Double64& inOffset);
    inline virtual Dtk_Object* Clone() { return new Dtk_OffsetSurface(*this); }
     virtual ~Dtk_OffsetSurface();
private:
     friend class Dtk_SmartPtr<Dtk_OffsetSurface>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_OffsetSurface * DtkDynamicCast(Dtk_Object * s);
 
     //constructors
     //! \brief Create an offset surface following surface normal
     //! \param [in] inSurf : Surface to be offset
     //! \param [in] inOffset : Size of offset
     //! \return Dtk_OffsetSurfacePtr created surface  
     static Dtk_OffsetSurfacePtr Create(const Dtk_SurfacePtr &inSurf, const Dtk_Double64& inOffset);
     //! \CreateCopy{in}
     static Dtk_OffsetSurfacePtr Create(const Dtk_OffsetSurface& in);
 
     //methods
     Dtk_Double64 GetOffset()const;
     Dtk_SurfacePtr GetSurface()const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
     virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_ErrorStatus ComputeNormal(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_dir &outDir) const;
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
     type_detk get_type_detk() const;
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     virtual void PrepareTransfo ();
 
     //! \brief Compute the result Surface with the offset applied. For some surfaces, their type can be conserved, otherwise it returns a NurbsSurface.
     Dtk_SurfacePtr ComputeOffsetedSurface() const;
 
     virtual Dtk_ErrorStatus _ComputeAnyDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue,  Dtk_Double64 inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,int exttype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative_withbasis(const Dtk_Double64 &inUvalue, const Dtk_Double64 &inVvalue, int inUmaxdiff,int inVmaxdiff,int inUVdiffsummax,Dtk_dir* outdirs,Dtk_dir* outdirsbasis,int exttype) const;
};
 
//! \SmartPtr{Dtk_FilletSurfacePtr}
class Dtk_FilletSurface : public Dtk_Surface
{
protected:
    struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
    enum { _typeID = DTK_TYPE_FILLET_SURFACE    }; 
    Dtk_FilletSurface();
    Dtk_FilletSurface(const Dtk_FilletSurface& );
     Dtk_FilletSurface( Dtk_FilletSurface&& ) DTK_NOEXCEPT;
    Dtk_FilletSurface(const Dtk_CurvePtr &inSpine, const Dtk_Double64& inAngle1, const Dtk_Double64& inAngle2,const Dtk_Double64& inConstantRadius,const Dtk_tab<Dtk_CurvePtr> &inAdjacentCurve,
          const Dtk_tab<Dtk_SurfacePtr> &inAdjacentSurface, const Dtk_tab<Dtk_Double64 >& inSpineParam,
          const Dtk_tab<Dtk_Double64 > &inKnots,const Dtk_Double64& inRadius1,const Dtk_Double64& inRadius2,const Dtk_NurbsSurfacePtr &inCorrespondingNurbs = NULL);
    inline virtual Dtk_Object* Clone() { return new Dtk_FilletSurface(*this); }
 
    virtual ~Dtk_FilletSurface();
private:
    friend class Dtk_SmartPtr<Dtk_FilletSurface>;
public:
 
    //downcasting
    int DtkDynamicType(const int& inId);
    static Dtk_FilletSurface * DtkDynamicCast(Dtk_Object * s);
 
    //constructors  
     //! \brief Calls full featured constructor to allocate a new object.
    static Dtk_FilletSurfacePtr Create(const Dtk_CurvePtr &inSpine, const Dtk_Double64& inAngle1, const Dtk_Double64& inAngle2, const Dtk_tab<Dtk_CurvePtr> &inAdjacentCurve,
          const Dtk_tab<Dtk_SurfacePtr> &inAdjacentSurface,
          const Dtk_tab<Dtk_Double64> &inSpineParam = Dtk_tab<Dtk_Double64>(), const Dtk_tab<Dtk_Double64> &inKnots = Dtk_tab<Dtk_Double64>(),
          const Dtk_Double64& inConstantRadius=-1.0,const Dtk_NurbsSurfacePtr &inCorrespondingNurbs = NULL);
     //! \CreateCopy{in}
     static Dtk_FilletSurfacePtr Create(const Dtk_FilletSurface& in);
 
    //methods
    Dtk_Double64 GetParam1()const;
    Dtk_Double64 GetParam2()const;
    Dtk_CurvePtr GetSpineCurve()const;
    Dtk_Size_t GetNumAdjacentCurves()const;
    Dtk_Size_t GetNumAdjacentSurfaces()const;
    Dtk_CurvePtr GetAdjacentCurve(const Dtk_Size_t &inIndex)const;
    Dtk_SurfacePtr GetAdjacentSurface(const Dtk_Size_t &inIndex)const;
    Dtk_tab< Dtk_Double64 > GetSpineParametrization()const;
 
     Dtk_tab< Dtk_Double64 > GetKnots() const;
     Dtk_Double64   GetConstantRadius() const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
    virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
    virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff,int inVdiff,Dtk_dir &outdir,int exttype) const;
     virtual Dtk_ErrorStatus _ComputeMultipleDerivative( Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUmaxdiff, int inVmaxdiff, int inUVdiffsummax, Dtk_dir* outdirs, int extendtype ) const;
     virtual Dtk_Size_t GetSize() const;
    virtual Dtk_ErrorStatus _Store(void*);
    type_detk get_type_detk() const;
    Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
};
 
//! \ingroup geom
//! \class Dtk_OffsetSurface 
//! \brief This is the Offset Surface Class.
//! \brief U parametrisation : like basis surface
//! \brief V parametrisation : like basis surface
//! \SmartPtr{Dtk_OffsetSurfacePtr}
//!
class Dtk_TransformedSurface : public Dtk_Surface
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
     enum { _typeID = DTK_TYPE_TRANSFORMED_SURFACE    }; 
     Dtk_TransformedSurface();
     Dtk_TransformedSurface(const Dtk_TransformedSurface& );
     Dtk_TransformedSurface( Dtk_TransformedSurface&& ) DTK_NOEXCEPT;
     Dtk_TransformedSurface(const Dtk_SurfacePtr &inSurf, const Dtk_transfo& inTransformation);
    inline virtual Dtk_Object* Clone() { return new Dtk_TransformedSurface(*this); }
     virtual ~Dtk_TransformedSurface();
private:
     friend class Dtk_SmartPtr<Dtk_TransformedSurface>;
public:
 
     //downcasting
     int DtkDynamicType(const int& inId);
     static Dtk_TransformedSurface * DtkDynamicCast(Dtk_Object * s);
 
     //constructors
     //! \brief Create an transformed surface 
     //! \param [in] inSurf : Surface to be transformed
     //! \param [in] inTransformation : transformation matrix
     //! \return Dtk_TransformedSurfacePtr created surface  
     static Dtk_TransformedSurfacePtr Create(const Dtk_SurfacePtr &inSurf, const Dtk_transfo& inTransformation);   
     //! \CreateCopy{in}
     static Dtk_TransformedSurfacePtr Create(const Dtk_TransformedSurface& in);
 
     //methods
     Dtk_transfo GetTransformation()const;
     Dtk_SurfacePtr GetSurface()const;
 
     //! \brief Get Surface Parametrisation  : Umin = outDomain[0]  Umax = outDomain[1] Vmin = outDomain[2]  Vmax = outDomain[3]
     virtual Dtk_ErrorStatus GetDomain(Dtk_Double64 outDomain[]) const;
     virtual Dtk_NurbsSurfacePtr ToNurbs(const Dtk_Double64 *inTrimDomain=NULL) const; 
     virtual Dtk_ErrorStatus ComputeUVPoint(const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt) const;
     virtual Dtk_Size_t GetSize() const;
     virtual Dtk_ErrorStatus _Store(void*);
     type_detk get_type_detk() const;
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
     Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff, int inVdiff, Dtk_dir &outdir, int extendtype) const;
     Dtk_ErrorStatus _ComputeMultipleDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUmaxdiff, int inVmaxdiff, int inUVdiffsummax, Dtk_dir* outdirs, int exttype) const;
};
 
//! \ingroup geom
//! \class Dtk_MeshSurface 
//! \brief This is the Mesh Surface Class.
//! \brief A Mesh Surface has no parametrisation, nor nurbs conversion feature. 
//! Use GetMesh to retrieve geometry.
//! \SmartPtr{Dtk_MeshSurfacePtr}
class Dtk_MeshSurface : public Dtk_Surface
{
protected:
     struct Dtk_Handle;       // Not defined here
     std::unique_ptr<Dtk_Handle> _Private;   // Handle
 
     enum { _typeID = DTK_TYPE_MESH_SURFACE };
     Dtk_MeshSurface();
     Dtk_MeshSurface( const Dtk_MeshSurface& );
     virtual ~Dtk_MeshSurface();
     inline virtual Dtk_Object* Clone() {return new Dtk_MeshSurface( *this );}
     Dtk_MeshSurface( const std::vector<Dtk_pnt>& inP, const std::vector<Dtk_UInt32>& index );
     Dtk_MeshSurface( const std::vector<Dtk_pnt>& inP, const std::vector<Dtk_UInt32>& index, const std::vector<Dtk_dir>& inD, const std::vector<Dtk_UInt32>& aindex );
private:
     friend class Dtk_SmartPtr<Dtk_MeshSurface>;
 
 
public:
     int DtkDynamicType( const int& inId );
     static Dtk_MeshSurface * DtkDynamicCast( Dtk_Object *inObject );
     type_detk get_type_detk() const;
     Dtk_ErrorStatus Transform( const Dtk_transfo& inTransfo );
     //! \brief No parametrisation
     //! \return dtkErrorCannotCompute
     virtual Dtk_ErrorStatus GetDomain( Dtk_Double64 outDomain[] ) const;
     //! \brief No corresponding nurbs nurface
     //! \return NULL
     virtual Dtk_NurbsSurfacePtr ToNurbs( const Dtk_Double64 *inTrimDomain = NULL ) const;
     //! \brief No parametrisation
     //! \return dtkErrorCannotCompute
     virtual Dtk_ErrorStatus ComputeUVPoint( const Dtk_Double64 &inUValue, const Dtk_Double64 &inVValue, Dtk_pnt &outpnt ) const;
     
     Dtk_ErrorStatus _ComputeAnyDerivative(Dtk_Double64 inUvalue, Dtk_Double64 inVvalue, int inUdiff, int inVdiff, Dtk_dir &outdir, int extendtype) const;
     //! \brief Add MeshSurface to Mesh
     //! \param [inout] outMeshPtr : Mesh corresponding to MeshSurface
     //! \return dtkNoError if success 
     Dtk_ErrorStatus AddMeshFaceToMesh( Dtk_MeshPtr &inoutMeshPtr ) const;
 
     //! \brief Get the Dtk_Mesh corresponding to MeshSurface
     //! \return Mesh corresponding to MeshSurface
     Dtk_MeshPtr GetMesh() const;
 
     //Internal Use
     static Dtk_MeshSurfacePtr Create( const std::vector<Dtk_pnt>& inP, const std::vector<Dtk_UInt32>& index );
     static Dtk_MeshSurfacePtr Create( const std::vector<Dtk_pnt>& inP, const std::vector<Dtk_UInt32>& index, const std::vector<Dtk_dir>& inD, const std::vector<Dtk_UInt32>& aindex );
     const std::vector<Dtk_pnt>& GetVertexArray() const;
     const std::vector<Dtk_dir>& GetNormArray() const;
     const std::vector<Dtk_UInt32>& GetVertexArrayIndex() const;
     const std::vector<Dtk_UInt32>& GetAttrArrayIndex() const;
 
};
 
 
 
/***************************************  END SURFACES **********************************/
 
 
#endif