str_feat_dtk.hpp

Go to the documentation of this file.

/**********************************************************
STR_FEAT.H
***********************************************************/
#ifndef _STR_FEAT_DTK_HPP_
#define _STR_FEAT_DTK_HPP_
 
/************************************
*    TYPES ENUMERES                     *
*************************************/
 
#include "util/util_stl_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include "util/util_geom_ptr_dtk.hpp"
#include "util/dtk_maindoc.hpp"
 
typedef struct cartesian_point_def Cartesian_point;
 
int CreateFeatNodeConnectorFromGeomIDs (const Dtk_tab <Dtk_ID> &inListOfGeomIDs, Dtk_NodeConnectorPtr & outNodeConnector); 
 
/* index for param tabs */
#define IND_LENGTH       0
#define IND_PITCH        0
#define IND_ANGLE        0
#define   IND_LENGTH1         1
#define IND_LENGTH2      2
#define IND_DEPTH        1
#define IND_DIAMETER     2
#define   IND_INSTANCES  1
#define   IND_SPACING         2
 
typedef enum DTK_BOOLEAN_TYPE {
     DTK_BOOLEAN_ADD = 0,
     DTK_BOOLEAN_REMOVE, 
     DTK_BOOLEAN_INTERSECT, 
     DTK_BOOLEAN_ASSEMBLE, 
     DTK_BOOLEAN_UNION_TRIM, 
     DTK_BOOLEAN_REMOVE_LUMP,
     NO_DTK_BOOLEAN_TYPE
} DTK_BOOLEAN_TYPE;
 
typedef enum DTK_PRISM_TYPE    {
 
     DTK_PRISM_PAD,
     DTK_PRISM_POCKET,
     DTK_PRISM_SURF_PAD, 
     NO_DTK_PRISM_TYPE
}DTK_PRISM_TYPE;
 
typedef enum DTK_LOFT_TYPE     {
 
     DTK_LOFT_POSITIVE,
     DTK_LOFT_NEGATIVE,
     NO_DTK_LOFT_TYPE
}DTK_LOFT_TYPE;
 
 
typedef enum    {
     DTK_REVOL_SHAFT,
     DTK_REVOL_GROOVE,
     NO_DTK_REVOL_TYPE
}DTK_REVOL_TYPE;
 
typedef enum   {
     DTK_SWEEP_RIB,
     DTK_SWEEP_SLOT,
     NO_SWEEP_TYPE
} DTK_SWEEP_TYPE;
 
 
typedef enum DTK_BODY_TYPE     {
 
     DTK_BODY_SOLID,
     DTK_BODY_SURFACE,
     NO_DTK_BODY_TYPE
} DTK_BODY_TYPE;
 
 
typedef enum    {
     DTK_POINT_ON_EDGE = 0,
     DTK_POINT_PLANE,
     DTK_POINT_INTERSECTION,
     DTK_POINT_MULTI_INTERSECTION,
     DTK_POINT_PROJECTION,
     DTK_POINT_SIMPLE_POINT,
     DTK_POINT_UNPROCESSED_POINT_CONSTRUCTION
}DTK_POINT_CONSTRUCTION;
 
typedef enum    {
     CST_RADIUS,
     VAR_RADIUS/*
                 FACE_FACE,
                 TRITANGENT*/,
                 NO_FILLET_TYPE
}FILLET_TYPE;
 
 
 
typedef enum    {
     FLAT = 0,
     V_BOTTOM,
     LIMITED,
     NO_HOLE_BOTTOM_TYPE
}HOLE_BOTTOM_TYPE;
 
typedef enum    {
     SIMPLE = 0,
     TAPERED,
     COUNTER_BORED,
     COUNTER_SUNK,
     COUNTER_DRILLED,//when Sunk and Bore have the same diameter. Catia v5 specific.
     COUNTER_DRILLED_2,//when Sunk and Bore have two different diameters.Needed for Pro/E.
     NO_HOLE_TYPE
}HOLE_TYPE;
 
typedef enum   {  
     LENGTH_LENGTH, 
     LENGTH_ANGLE
} CHAMFER_TYPE;
 
typedef enum    {
     EXTREME_ANCHOR_POINT = 0,
     MIDDLE_ANCHOR_POINT,
     NO_ANCHOR_TYPE
} ANCHOR_TYPE;
 
 
typedef enum    {
     CUBIC = 0,
     LINEAR,
     NO_FILLET_VARIATION_TYPE
}FILLET_VARIATION_TYPE;
 
typedef enum    {
     TANGENCY = 0,
     MINIMAL,
     NO_PROPAGATION_TYPE
}PROPAGATION_TYPE;
 
typedef enum   {
     KEEP_ANGLE = 0,
     EXTRACTION_DIRECTION,
     REFERENCE_SURFACE,
     NO_PROFILE_CONTROL_TYPE
} PROFILE_CONTROL_TYPE; 
 
typedef enum   {
     DTK_RECT_PATTERN,
     DTK_CIRC_PATTERN,
     DTK_USER_PATTERN,
     DTK_UNKNOWN_PATTERN
}DTK_PATTERN_TYPE;
 
 
typedef enum    {
     DTK_FEATURE_SELECT = 0,
     DTK_BODY_SELECT,
     DTK_FACE_SELECT,
     NO_DTK_OBJECT_TYPE
}DTK_OBJECT_TYPE;
 
 
typedef enum    {
     CST_ANGLE,
     VAR_ANGLE,
     REFLECT_LINE,       // Draft with a reflect line instead of the neutral element   
     ADVANCED_DRAFT,          // The advanced draft containing a draft (standard or reflect line ) with possibilities of two sides support 
     NO_DRAFT_TYPE
}DRAFT_TYPE;
 
typedef enum    {
     MULTI_FACES,
     NEUTRAL_ELEMENT,
     NO_SELECTION_MODE
}SELECTION_MODE;
 
 
typedef enum    {
     CONE = 0,
     SQUARE , 
     NO_DRAFT_FORM
}DRAFT_FORM;
 
typedef enum    {
     INDEPENDENT,
     DRIVING_DRIVEN,
     FITTED,
     NO_DRIVING_MODE
}DRIVING_MODE;
 
typedef enum    {
     FIRST_SIDE,
     SECOND_SIDE,
     NO_DRIVING_SIDE
}DRIVING_SIDE;
 
typedef enum   {
     DTK_ROOT,                // The root node which allow the entry for parsing the whole tree
     DTK_COMPLEX_FEATURE,     // This is a non terminal node as a body composed of multiple features, or a boolean operation 
     DTK_SIMPLE_FEATURE,      // This is the terminal node which consists of the simple feature which couldn't have children 
     NO_NODE_TYPE
} NODE_TYPE; 
 
 
typedef enum   {
     DTK_UNKNOWN_BEHAVIOR = 0,                    
     DTK_ADD_MATERIAL,    
     DTK_REMOVE_MATERIAL,           
     DTK_TRANSITION,
     DTK_DUPLICATION,
     DTK_BOOLEAN_OPERATION
} DTK_FEAT_BEHAVIOR; 
 
 
typedef enum    {
     DTK_DIRECTION_DISTANCE,
     DTK_POINT_TO_POINT,
     DTK_COORDINATES,    
     DTK_NO_TRANSLATE_TYPE
}TRANSLATE_TYPE;
 
typedef enum    {
     DTK_AXIS_ANGLE,
     DTK_AXIS_TWO_ELEMENTS,
     DTK_THREE_PNTS,     
     DTK_NO_ROTATE_TYPE
}ROTATE_TYPE;
 
typedef enum {
     DTK_FROM_SIDE, // Raidisseur Simple
     DTK_FROM_TOP,  // Raidisseur en Reseau
     DTK_NO_STIFFENER_MODE
}STIFFENER_MODE; 
 
 
typedef enum {
     DTK_SHM_DESIGN, 
     DTK_SHM_PRODUCTION,
     DTK_SHM_GENERATIVE_DESIGN,
     DTK_SHM_AEROSPACE_DESIGN, 
     DTK_SHM_NEW,   
     NO_DTK_SHM_MODULE_TYPE
} DTK_SHM_MODULE_TYPE;
 
 
typedef enum {
     DTK_COUPLING_RATIO,
     DTK_COUPLING_TANGENCY,
     DTK_COUPLING_TANGENCY_THEN_CURVATURE,
     DTK_COUPLING_VERTICES,
     DTK_NO_COUPLING
}COUPLING_TYPE;
 
typedef enum {
     DTK_PIPE_UNKNOWN, 
     DTK_PIPE_CONVEYOR_RUN, 
     DTK_PIPE_PIPE_RUN,
     DTK_PIPE_RACEWAY_RUN,
     DTK_PIPE_CONDUIT_RUN,
     DTK_PIPE_DUCT_RUN,
     DTK_PIPE_HYDRAULICS_RUN,
     DTK_PIPE_LINE,
     DTK_PIPE_ELBOW, 
     DTK_PIPE_ELBOW_SEGMENTS,
     DTK_PIPE_SPLINE, 
     DTK_PIPE_ELEC3D, 
     DTK_PIPE_PROFILE,
     DTK_PIPE_SPHERICAL_TERMINATOR,   // From CATIA V4 only 
     DTK_PIPE_EXCENTRIC_CONE    // from CATIA V4 only
}DTK_PIPE_TYPE;
 
typedef enum {
     DTK_NO_SECTION, 
     DTK_SECTION_ROUND,            // Defined with a Diameter
     DTK_SECTION_RECTANGULAR, // Defined with a Height and Width 
     DTK_SECTION_FLAT_OVAL,        // Defined with a Height and Width 
     DTK_SECTION_RADIUS_CORNER,    // Defined with a Height, Width and Radius Corner
     DTK_SECTION_DOUBLE_RIDGE // Defined with a Height and Width
}DTK_PIPE_SECTION_TYPE;
 
typedef enum {
     DTK_THREAD_UNKNOWN, 
     DTK_THREAD_TAP,               // Define a Tap
     DTK_THREAD_THREAD,       // Define a Thread
}DTK_THREAD_TYPE;
 
typedef enum {
     DTK_THREAD_DIMENSION = 0,          // User defined depth value 
     DTK_THREAD_SUPPORT_DEPTH,     // Thread Depth is of the same of its support (hole, cylinder...) 
     DTK_THREAD_UP_TO_PLANE,       // The thread limit is defined according to a plane. Get the plane reference using get_thread_limit()
}DTK_THREAD_LIMIT_TYPE;
 
 
 
/**@brief    Feature types    */
enum DTK_FEATURE_TYPE{
     DTK_FEAT_UNKNOWN = 0,
     DTK_FEAT_PAD,
     DTK_FEAT_POCKET,
     DTK_FEAT_HOLE,
     DTK_FEAT_HOLE_SERIES,
     DTK_FEAT_UDF,
     DTK_FEAT_THREAD,
     DTK_FEAT_GROOVE,
     DTK_FEAT_SHAFT,
     DTK_FEAT_SHELL,
     DTK_FEAT_FILLET,
     DTK_FEAT_PRISM,
     DTK_FEAT_REVOL,
     DTK_FEAT_SWEEP,
     DTK_FEAT_RIB,
     DTK_FEAT_SLOT,
     DTK_FEAT_CHAMFER,
     DTK_FEAT_SPLIT_SURF,
     DTK_FEAT_THICK_SURF,
     DTK_FEAT_SEW_SURF,
     DTK_FEAT_CLOSE_SURF,
     DTK_FEAT_PATTERN,
     DTK_FEAT_RECT_PATTERN,
     DTK_FEAT_CIRC_PATTERN,
     DTK_FEAT_USER_PATTERN,
     DTK_FEAT_MIRROR,
     // SURFACIQUES
     DTK_FEAT_SURF_PAD, 
     DTK_FEAT_SURF_REVOL,
     // BOOL
     DTK_FEAT_BOOLEAN,
     DTK_FEAT_ADD,
     DTK_FEAT_REMOVE,
     DTK_FEAT_INTERSECT,
     DTK_FEAT_ASSEMBLE,
     DTK_FEAT_UNION_TRIM, 
     DTK_FEAT_REMOVE_LUMP,
     // NEW
     DTK_FEAT_DRAFT,
     DTK_FEAT_TRANSLATE,
     DTK_FEAT_ROTATE,
     DTK_FEAT_REMOVE_FACE,
     DTK_FEAT_STIFFENER,
     DTK_FEAT_FACE_FILLET,
     DTK_FEAT_TRITANGENT_FILLET,
     DTK_FEAT_MULTI_PAD,
     DTK_FEAT_MULTI_POCKET,
     DTK_FEAT_LOFT,
     DTK_FEAT_THICKNESS,
     DTK_FEAT_SCALING,        
 
     DTK_FEAT_HOLE_FOR_FASTENER,
 
     // Feat Surfacique 
     DTK_FEAT_SURFACE,
 
     // Corps (Solide, Surfacique) 
     DTK_FEAT_BODY,
     DTK_FEAT_SOLID_BODY, 
     DTK_FEAT_GEOMETRICAL_SET,
 
     //Solides Importes 
     DTK_FEAT_IMPORT,
 
     //General Sheet Metal Type 
     DTK_FEAT_SHEET_METAL    , 
     DTK_FEAT_POSITIVE_LOFT,
     DTK_FEAT_NEGATIVE_LOFT,
 
     DTK_FEAT_MULTI_PRISM, 
     DTK_FEAT_REPLACE_FACE, 
     DTK_FEAT_SYMMETRY, 
 
     //user defined
     DTK_FEAT_USER_DEFINED,
 
     //Technological Result Hole
     DTK_FEAT_TTR_HOLE,
 
     //Technological Result Thread
     DTK_FEAT_TTR_THREAD,
 
     //Piping and Tubing
     DTK_FEAT_PIPE,
 
     //Spot Point
     DTK_FEAT_SPOT_POINT,
 
     
     //Composite
     DTK_FEAT_COMP_STACKING,
     DTK_FEAT_COMP_PLIES_GROUP,
     DTK_FEAT_COMP_SEQUENCE,
     DTK_FEAT_COMP_PLY,
     DTK_FEAT_COMP_SECTION_GROUP,
     DTK_FEAT_COMP_PLY_SECTION,
     DTK_FEAT_COMP_MATERIAL,
     DTK_FEAT_COMP_MATERIAL_TYPE,
 
     DTK_FEAT_COMP_STD_CONTOUR,
     DTK_FEAT_COMP_ELEMENT_GEOM,
     DTK_FEAT_COMP_LAMINATE,
     DTK_FEAT_COMP_ZONES_GROUP,
     DTK_FEAT_COMP_TRANS_ZONES_GROUP,
     DTK_FEAT_COMP_ZONE,
     DTK_FEAT_COMP_TRANS_ZONE,
     DTK_FEAT_COMP_PARAMETERS,
     DTK_FEAT_COMP_PRELIMINARY_DESIGN
 
 
};
 
/**@brief    Surface Feature types    */
enum DTK_SURF_FEATURE_TYPE 
{
     DTK_FEAT_SURF_UNKNOWN = 0
     // TODO: Complete the list of surface features defined in wireframe and surface module in catiaV5
     // ex: EXTRUDE, REVOLVE, SPHERE, CYLINDER, OFFSET, SWEEP, FILL, MULTISECTION, BLEND, 
     // Operations: JOIN, HEALING, UNTRIm, ROTATE, etc...     
}; 
 
/**@brief    Sheet Metal Feature types    */
enum DTK_SHM_FEATURE_TYPE 
{
     DTK_FEAT_SHM_UNKNOWN = 0, 
 
     //Sheet Metal Design Features 
     DTK_FEAT_SHM_WALL_RECOGNITION, 
     DTK_FEAT_SHM_WALL, 
     DTK_FEAT_SHM_WALL_ON_EDGE, 
     DTK_FEAT_SHM_EXTRUSION,
 
     DTK_FEAT_SHM_BEND_AUTOMATIC, 
     DTK_FEAT_SHM_BEND_CONIC, 
     DTK_FEAT_SHM_BEND_FROM_FLAT,
     DTK_FEAT_SHM_BEND, 
 
     DTK_FEAT_SHM_FLANGE, 
     DTK_FEAT_SHM_HEM, 
     DTK_FEAT_SHM_TEAR_DROP, 
     DTK_FEAT_SHM_SWEPT_FLANGE, 
 
     DTK_FEAT_SHM_CUTOUT, 
     DTK_FEAT_SHM_SPLIT, 
 
     DTK_FEAT_SHM_STAMP_POINT,
     DTK_FEAT_SHM_STAMP_CURVE,
     DTK_FEAT_SHM_STAMP_SURFACE,
     DTK_FEAT_SHM_STAMP_USER,
     DTK_FEAT_SHM_EXTRUDED_HOLE,          
     DTK_FEAT_SHM_BRIDGE, 
     DTK_FEAT_SHM_LOUVER,
     DTK_FEAT_SHM_STIFFENING_RIB, 
 
     DTK_FEAT_SHM_PATTERN_RECT,
     DTK_FEAT_SHM_PATTERN_CIRC, 
     DTK_FEAT_SHM_PATTERN_USER, 
 
     DTK_FEAT_SHM_CORNER_RELIEF, 
 
     DTK_FEAT_SHM_CHAMFER, 
     DTK_FEAT_SHM_CORNER, 
 
     //Generative Sheet Metal Design Features 
     //DTK_FEAT_SHM_RECOGNIZE 
     DTK_FEAT_SHM_HOPPER, 
     DTK_FEAT_SHM_ROLLED_WALL, 
 
     DTK_FEAT_SHM_CUTOUT_CIRCULAR, 
     DTK_FEAT_SHM_HOLE, 
 
     DTK_FEAT_SHM_BEAD,
     DTK_FEAT_SHM_FLANGED_CUTOUT,
     DTK_FEAT_SHM_FLANGED_HOLE,         
     DTK_FEAT_SHM_STAMP_CIRCULAR, 
     DTK_FEAT_SHM_DOWEL,
 
     DTK_FEAT_SHM_MIRROR, 
 
     //Aerospace Sheet Metal Design 
     DTK_FEAT_SHM_WEB,
     DTK_FEAT_SHM_SURFACIC_FLANGE, 
     DTK_FEAT_SHM_JOGGLE            
};
 
/// @cond NO_DOXYGEN_DOC
/************************************
* STRUCT AUXILIAIRES                    *
*************************************/
typedef struct tab_ID_def
{
     int         nb_IDs;             /*nb de ID*/
     long     *  IDs;                /*tab_ID*/
}Tab_ID;
 
typedef struct dtk_feat_geom_elt_def {
 
     Tab_ID    *    elts;
     int            nb_elts;
 
} Dtk_feat_geom_elt;
 
 
class Dtk_feat;
typedef Dtk_SmartPtr<Dtk_feat> Dtk_FeaturePtr;
 
 
/**
@brief Geometry
*/
class Dtk_feat_geometry {
public:
     Dtk_feat_geom_elt   **   profiles;
     int                 nb_profiles;
 
     /* 20040630 */
     long           nb_ids;
     int                           _ToNodeID;     //available only for Dtk_Component/Dtk_Node method, used to be stored in DtkNodeConnector
     int                           _ToCompID;     //available only for Dtk_Component/Dtk_Node method, used to be stored in DtkNodeConnector
     Dtk_tab<Dtk_NodeConnectorPtr> _NodeConnectors;
 
     Dtk_feat_geometry ();
     // Copy constructor
     Dtk_feat_geometry (const Dtk_feat_geometry& );
 
     ~Dtk_feat_geometry ();
 
     //! \brief     Returns the inner geometric ids.
     //! \deprecated Use GetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> & outNodeConnector) const method instead.
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK | ISOK  
     //! \remark
     SetAsDeprecated("Undefined", "Use GetNodeConnectors")
     int  get_ids        (long **, int*);
 
     //! \brief     Returns the inner geometric ids.
     //! \deprecated Use GetNodeConnectors
     SetAsDeprecated("Undefined", "Use GetNodeConnectors")
     Dtk_tab<Dtk_Int32> GetAllGeomIds() const;
 
 
 
     //! \brief     Returns the Node Connector to retrieve geometric entities using _ReadConnectedEntity. 
     //! \brief     This method is available only for Dtk_Component/Dtk_Node based approach
     //! \deprecated Use GetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> & outNodeConnector) const method instead.
     //! \param [in/out]     
     //! \param [out]   outNodeConnector
     //! \return    NOTOK | ISOK  
     //! \remark
     int get_NodeConnector (Dtk_NodeConnectorPtr & outNodeConnector) const;
 
     //! \brief     Returns the Node Connector to retrieve geometric entities  
     //! \param [out]   outNodeConnector
     //! \return    dtkNoError if OK
     Dtk_ErrorStatus GetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> & outNodeConnector) const;
 
     Dtk_ErrorStatus SetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> inTabConnectors);
 
} ;
/// @endcond
 
/**
@brief Feature Axis
*/
class Dtk_feat_axis {
 
public :
     Dtk_dir             direction;
     Dtk_pnt             origin;
     Bool           reverse;
public:
 
 
     Dtk_feat_axis ();
     ~Dtk_feat_axis ();
 
     //! \brief     Returns origin.
     //! \param [in/out]   Dtk_pnt  
     //! \param [out]   Dtk_pnt ( double[3] )
     //! \return    NOTOK | ISOK  
     //! \remark
 
     int get_origin (Dtk_pnt *);
     Dtk_pnt GetOrigin() const {return origin;}
 
     //! \brief     Returns direction.
 
     //! \param [in/out]   Dtk_dir  
     //! \param [out]   Dtk_dir ( double[3] )
     //! \return    NOTOK | ISOK  
     //! \remark
 
     int get_direction (Dtk_dir *);
     Dtk_dir GetDirection() const {return direction;}
 
     Dtk_bool IsReversed() const {return reverse;}
 
} ;
 
 
class Dtk_feat_sketch
{
public:
     Dtk_pnt             origin;
     Dtk_dir             hdir;
     Dtk_dir             vdir;
     Dtk_feat_axis  *         axis;
     Dtk_feat_sketch();
     ~Dtk_feat_sketch();
 
} ;
 
/**
@brief Limit Feature : Some features contain one or several limit components which describe how their own shape is limited. 
 
*/
class Dtk_feat_limit {
 
 
public:
 
      enum LIMIT_TYPE     
      {
          DEFAULT                 = 0,
        LENGTH                  = 1,
          UP_TO_NEXT              = 2,
          UP_TO_LAST              = 3,
          UP_TO_PLANE             = 4,
          UP_TO_SURFACE           = 5,
          UP_THRU_NEXT_LIMIT      = 6,
          BIDIRECTIONAL           = 7,
          NO_LIMIT_TYPE           = 8,
        BLIND                   = 1, //= LENGTH
     };
 
 
     LIMIT_TYPE          type;
     double              val;      // length
     Dtk_feat_geometry   *    reference_object;
 
 
     Dtk_feat_limit();
     Dtk_feat_limit(const Dtk_feat_limit& inFeatLimit);
     ~Dtk_feat_limit();
 
     //! \brief     Returns limit type.  
     //! \param [in/out]     
     //! \param [out]   LIMIT_TYPE
     //! \return    NOTOK | ISOK  
     //! \remark    
 
     int get_type (LIMIT_TYPE *);
     Dtk_string GetTypeAsString() const;
     LIMIT_TYPE GetType() const {return type;}
 
     //! \brief     Returns limit length.      
     //! \param [in/out]     
     //! \param [out]   length value
     //! \return    NOTOK | ISOK  
     //! \remark    represents either an length value (length) 
 
     int get_val (double *);
     Dtk_Double64 GetVal() const {return val;}
 
 
     //! \brief     Returns the limit reference object if any.      
     //! \param [in/out]     
     //! \param [out]   offset value
     //! \return    NOTOK | ISOK  
     //! \remark    
 
     int get_reference_object (Dtk_feat_geometry  **);
     Dtk_feat_geometry   *GetRefenceObject()const {return reference_object;}
 
 
 
} ;
 
 
/**
@brief Face to thicken
*/
class Dtk_feat_thickness_face {
public:
 
     Dtk_feat_geometry   *    face;     
     double                        thickness;
 
 
 
     //! \brief     Constructor of Thickness Face Feature        
     //! \param [in/out]
     //! \param [out]    Allocated thickness face feature  
     //! \return    
     //! \remark
 
     Dtk_feat_thickness_face ();
 
 
     //! \brief     Destructor of a Thickness face feature 
     //! \param [in]   Thickness Face feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Thickness Face Feature  
     //! \remark
 
     ~Dtk_feat_thickness_face ();
 
 
     //! \brief     Get the face geometry of the feature Thickness Face 
     //! \param [in]   Thickness face feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_geometry
     //! \return    face geometry of Thickness Feature  
     //! \remark
 
     int get_face (Dtk_feat_geometry **);
 
 
     //! \brief     Get the  thickness of the feature Thickness Face 
     //! \param [in]   Thickness face feature   
     //! \param [in/out]     
     //! \param [out]   double
     //! \return     Thickness value of Thickness Feature  
     //! \remark
 
     int get_thickness (double *);
 
} ;
 
 
/**
@brief Thickness Feature
*/
class Dtk_feat_thickness {
 
public:
     double                   thickThin1;
     double                   thickThin2;
     Bool                thick;
     Bool                neutralFiber;
     Bool                mergeThin;
 
     Dtk_feat_thickness ();
     ~Dtk_feat_thickness ();
 
     //! \brief     Returns thickness.      
     //! \param [in/out]     
     //! \param [out]   Bool
     //! \return    NOTOK | ISOK  
     //! \remark    DTK_FALSE if no thickness, DTK_TRUE else
 
     int get_thick (Bool *);
 
     //! \brief     Returns neutral fiber flag.      
     //! \param [in/out]     
     //! \param [out]   Bool
     //! \return    NOTOK | ISOK  
     //! \remark    DTK_TRUE : inner and outer thickness are equal, take thin1 value
 
     int get_neutral_fiber (Bool *);
 
     //! \brief     Returns inner thickness value.      
     //! \param [in/out]     
     //! \param [out]   double
     //! \return    NOTOK | ISOK  
     //! \remark    
 
     int get_thin1 (double *);
 
     //! \brief     Returns outer thickness value.      
     //! \param [in/out]     
     //! \param [out]   double
     //! \return    NOTOK | ISOK  
     //! \remark    
 
     int get_thin2 (double *);
     int get_merge_thin (Bool *);
 
} ;
 
 
/**
@brief Face to remove
*/
class Dtk_feat_shell_face {
public:
 
     Dtk_feat_geometry   *    face;
 
     double                   inside_thickness;
     double                   outside_thickness;
 
 
     //! \brief     Constructor of Shell Face Feature   
     //! \param [in/out]
     //! \param [out]    Allocated shell face feature  
     //! \return    
     //! \remark
 
     Dtk_feat_shell_face ();
 
     //! \brief     Destructor of a shell face feature 
     //! \param [in]   Shell Face feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Shell Face Feature  
     //! \remark
 
     ~Dtk_feat_shell_face ();
 
     //! \brief     Get the face geometry of the feature Shell Face 
     //! \param [in]   Shell face feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_geometry
     //! \return    face geometry of Shell Feature  
     //! \remark
 
     int get_face (Dtk_feat_geometry **);
 
     //! \brief     Get the inside thickness of the feature Shell Face 
     //! \param [in]   Shell face feature   
     //! \param [in/out]     
     //! \param [out]   double
     //! \return    Inside Thickness of Shell Feature  
     //! \remark
 
     int get_inside_thickness (double *);
 
     //! \brief     Get the outside thickness of the feature Shell Face 
     //! \param [in]   Shell face feature   
     //! \param [in/out]     
     //! \param [out]   double
     //! \return    Outside Thickness of Shell Feature  
     //! \remark
 
     int get_outside_thickness (double *);
 
 
} ;
 
 
 
/*
Tolerance set (value + tolerance min + tolerance max)
*/
class Dtk_feat_tolerance_set {
public :
     double              tol_inf;
     double              tol_sup;
 
     Dtk_Double64 GetSuperiorTolerance() const {return tol_sup;}
     Dtk_Double64 GetInferiorTolerance() const {return tol_inf;}
 
} ;
 
 
typedef double Dtk_counter_params [3]; /* angle, depth, diameter */
typedef double Dtk_hole_params[3];      /* angle, depth, diameter */
typedef double Dtk_chamfer_params[3];   /* angle, length1, length2 */
typedef double Dtk_thread_params [3];   /* pitch, depth, diameter */
 
 
/************************************
*              FEATURES                 *
*************************************/
 
/**
@brief    Prism Feature : A Prism extrudes a profile along a specific direction. A Pad adds material, a Pocket removes material. 
*/
class Dtk_feat_prism {
 
public:
     DTK_PRISM_TYPE type;                         
     Dtk_feat_geometry   *    profiles;
     Dtk_feat_axis       *    axis;               
     Bool                sym;                
     Bool                normal_to_surface;  
     int                      side;                    
     Dtk_feat_thickness  *    thickness;          
     Dtk_feat_limit      *    first_limit;   
     Dtk_feat_limit      *    second_limit;
     Cartesian_point             **     anchor;
     int                             nb_anchors;
     char                          **   annotation;
 
public :
 
 
     //! \brief   Constructor of Prism Feature                    
     //! \param [in/out]                                                  
     //! \param [out]   Allocated prism feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     Dtk_feat_prism ();
 
     //! \brief     Destructor of a prism feature 
     //! \param [in]   Prism feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Prism Feature  
     //! \remark           
 
 
     ~Dtk_feat_prism ();
 
     //! \brief   Returns Prism type                                               
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]  DTK_PRISM_TYPE                      
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_type                  (DTK_PRISM_TYPE *);
 
     //! \brief   Tests whether the symmetrical extension is set or not.                            
     //! \param [in]   Prism Feature         
     //! \param [in/out]                 
     //! \param [out]    Boolean            
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                        
 
 
     int  get_sym                       (Bool *);
 
     //! \brief     Returns the closing side of the open profile (side flag).                                
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Flag                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    When the profile is open, specifies which side of the profile will be used for closing (legal values = 1 for direct axis, -1 for indirect)  
 
 
     int get_inner_side            (int *);
 
     //! \brief     Returns the extrusion direction.                                                 
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   DTK Axis                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_axis                 (Dtk_feat_axis **);
 
     //! \brief     Tests whether the direction is opposite to the reference or not.                                  
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Boolean                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_direction_reversed   (Bool *);
 
     //! \brief     Returns the second limit feature.                                         
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Second Limit Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_start_limit               (Dtk_feat_limit **);
 
     //! \brief     Returns the first limit feature.                                                   
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Second Limit Feature                                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_end_limit            (Dtk_feat_limit **);
 
     //! \brief   Returns the profile internal component.                                                
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Profile geometry                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
     //! \brief   Returns thickness of a prism.                                                
     //! \param [in]   Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_thickness (the internal and external thickness)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_thickness (Dtk_feat_thickness **);
};
 
/**
@brief    Revol Feature : A Revol extrudes a profile around an axis. The profile sketch must contain an axis used as the revolution axis. A Shaft adds material, a Groove removes material. 
*/
class Dtk_feat_revol {
 
public:                       
     Dtk_feat_geometry   *    profiles;      
     Dtk_feat_axis       *    axis;     
     Dtk_feat_thickness  *    thickness;     
     double                   first_angle;        
     double                   second_angle;       
     int                      side;          
     DTK_REVOL_TYPE      type;     
     
 
public:
 
 
     //! \brief     Constructor of Revol Features
     //! \param [in/out]
     //! \param [out]    
     //! \return    Allocated Revol Feature
     //! \remark
 
 
     Dtk_feat_revol ();
 
     //! \brief     Destructor of Revol Features
     //! \param [in]     Revol feature to disallocate
     //! \param [in/out]
     //! \param [out]    
     //! \return    Disallocated revol feature
     //! \remark    You don't have to test revol feature type
 
 
     ~Dtk_feat_revol ();
 
     //! \brief     Returns revol type 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    DTK_REVOL_TYPE
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int get_type                  (DTK_REVOL_TYPE *);
 
     //! \brief     Returns the second angle value. 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    Second Angle Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int  get_start_angle               (double *);
 
     //! \brief     Returns the first angle value. 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    First Angle Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int  get_end_angle            (double *);
 
     //! \brief     Returns the revolution axis. 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    Revolution Axis
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int  get_reference_axis       (Dtk_feat_axis **);
 
     //! \brief     Returns the profile internal component. 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    Profile feature
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
     //! \brief     Returns the thickness feature. 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    Thickness Feature
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
 
     int get_thickness             (Dtk_feat_thickness **);
 
     //! \brief     Returns the closing side of the open profile (side flag). 
     //! \param [in]     Revol Feature
     //! \param [in/out]
     //! \param [out]    Side flag
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    When the profile is open, specifies which side of the profile will be used for closing (legal values = 1 for direct axis, -1 for indirect)
 
     int get_inner_side            (int*);
 
};
 
 
/**
@brief Chamfer ribbon 
*/
class Dtk_feat_chamfer_ribbon {
 
public:
 
     Dtk_feat_geometry   **   objects;
     int                           nb_objects;
     Bool                     reverse;
 
     Dtk_feat_chamfer_ribbon ();
     ~Dtk_feat_chamfer_ribbon ();
 
     //! \brief   Returns objects number for each ribbon                                            
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   int 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_nb_objects (int *);
 
     //! \brief   Returns geometries objects fro each Ribbon                                            
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_objects (Dtk_feat_geometry ***);
 
     //! \brief   Returns reverse value for a ribbon                                            
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   bool (DTK_TRUE if reversed ribbon, DTK_FALSE if not reversed ribbon) 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_reverse (Bool *);
 
} ;
 
 
/**
@brief Chamfer feature
*/
class Dtk_feat_chamfer {
 
public:
 
     Dtk_chamfer_params            chamfer_params;
 
     Dtk_feat_chamfer_ribbon  **   ribbons;
     int                                nb_ribbons;
 
     PROPAGATION_TYPE              propagation;
     CHAMFER_TYPE                  type;
 
     Dtk_feat_chamfer ();
 
     ~Dtk_feat_chamfer ();
 
     //! \brief   Returns Chamfer ribbons number                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   int 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_nb_ribbons (int *);
 
     //! \brief   Returns Chamfer ribbons                                              
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_chamfer_ribbon 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_ribbons (Dtk_feat_chamfer_ribbon     ***);
 
     //! \brief   Returns Chamfer propagation                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   PROPAGATION_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_propagation (PROPAGATION_TYPE*);
 
     //! \brief   Returns Chamfer type                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]  CHAMFER_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_type (CHAMFER_TYPE*);
 
     //! \brief   Returns Chamfer Angle                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   double 
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_angle (double *a);
 
     //! \brief   Returns Chamfer Length1                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   double   
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_length1 (double *a);
 
     //! \brief   Returns Chamfer Length2                                               
     //! \param [in]   Chamfer Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   double  
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_length2 (double *a);
 
} ;
 
/**
@brief    Feature Inner Thread
*/
class Dtk_feat_inner_thread {
 
public:
     Dtk_string                    thread_definition_type;
     Dtk_string                    thread_definition_value;
 
     Dtk_thread_params   thread_params;
     Dtk_feat_tolerance_set   * tol_thread_params[3];
 
     Bool                right_threaded;
     Bool                no_standard_table;
     Bool                normal_to_surface;
     DTK_THREAD_TYPE          thread_type;             //Thread or Tap 
 
     DTK_THREAD_LIMIT_TYPE    thread_limit_type; // Dimension, Support Depth, or Up to Plane 
     Dtk_feat_geometry*       thread_limit_reference;  // refer to a plane; used only if thread limit type is "Up To Plane"
 
 
public:
 
 
     //! \brief     Constructor of Inner Thread Feature     
     //! \param [in/out] 
     //! \param [out]    Allocated inner thread feature  
     //! \return    
     //! \remark    Inner thread contains several threading parameters such as diameter, depth, pitch, type... It is used for inner thread of a hole (Dtk_feat_hole) and in a thread (Dtk_feat_thread)
 
 
     Dtk_feat_inner_thread ();
 
     //! \brief     Destructor of Inner Thread Feature      
     //! \param [in/out] 
     //! \param [out]    Free Inner Thread feature  
     //! \return    
     //! \remark
 
 
     ~Dtk_feat_inner_thread ();
 
     //! \brief     Returns the thread diameter
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Threading diameter
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    
 
 
     int get_diameter         (double *);
     Dtk_Double64 GetDiameter() const {return  thread_params[IND_DIAMETER];}
 
     //! \brief     Returns the thread  diameter with tolerance values if any
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread diameter & tolerances if any
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the thread diameter with get_diameter_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
 
     int get_diameter_with_tol     (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDiameterTolerance() const {return tol_thread_params[IND_DIAMETER]; }
 
     //! \brief     Tests whether there is a tolerance set on thread diameter
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    
 
 
     int get_diameter_has_tol (Bool *);
     Dtk_bool HasDiameterTolerance()const {return !(tol_thread_params[IND_DIAMETER] == NULL);}
 
 
     //! \brief     Returns the thread  depth
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread depth
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_depth            (double *);
     Dtk_Double64 GetDepth() const {return  thread_params[IND_DEPTH];}
     //! \brief     Returns the thread  depth with tolerance  values if any
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread depth & tolerances if any
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the thread depth with get_depth_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_depth_with_tol        (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDepthTolerance() const {return tol_thread_params[IND_DEPTH]; }
 
     //! \brief     Tests whether there is a tolerance set on thread depth
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_depth_has_tol    (Bool *);
     Dtk_bool HasDepthTolerance()const {return !(tol_thread_params[IND_DEPTH] == NULL);}
     //! \brief     Returns the threading  pitch
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread pitch
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_pitch            (double *);
     Dtk_Double64 GetPitch() const {return  thread_params[0];}
 
     //! \brief     Returns the thread  pitch with tolerance values if any
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread pitch & tolerances if any
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the thread pitch with get_dtk_feat_inner_thread_pitch_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_pitch_with_tol        (double *, double *, double *);
     Dtk_feat_tolerance_set *GetPitchTolerance() const {return tol_thread_params[0]; }
 
     //! \brief     Tests whether there is a tolerance set on thread pitch
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_pitch_has_tol    (Bool *);
     Dtk_bool HasPitchTolerance()const {return !(tol_thread_params[IND_DEPTH] == NULL);}
 
     //! \brief     Tests whether the thread is rigth-threaded
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Bool (DTK_TRUE = right, DTK_FALSE = left)
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    
 
     int get_right_threaded   (Bool *);
     Dtk_bool IsRightThreaded() const {return right_threaded;}
     Dtk_bool IsNoStandardTable() const {return no_standard_table;}
     
 
     //! \brief     Returns the thread standard definition type if any
     //! \param [in]     Inner Thread feature
     //! \param [out]    Thread definition type - must call delete[] 
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    "Metric_Thick_Pitch" | "Metric_Thin_Pitch" 
     //! \deprecated Use GetDefinitionType()
     SetAsDeprecated("2024.2", "Use GetDefinitionType()")
     int get_def_type    (wchar_t **);
     Dtk_string GetDefinitionType() const {return thread_definition_type; }
 
     //! \brief     Returns the thread standard definition value if any
     //! \param [in]     Inner Thread feature
     //! \param [out]    Thread definition value  - must call delete[] 
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    ex : "M8", "M12"...
     //! \deprecated Use GetDefinitionValue()
     SetAsDeprecated("2024.2", "Use GetDefinitionValue()")
     int get_def_value        (wchar_t **);
     Dtk_string GetDefinitionValue() const {return thread_definition_value; }
 
     //! \brief     Returns the thread type value 
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread definition type
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    ex : "M8", "M12"...
 
     int get_thread_type      (DTK_THREAD_TYPE&);
     Dtk_string GetTypeAsString() const;
     DTK_THREAD_TYPE GetType() const {return thread_type;}
     
 
     //! \brief     Returns the thread limit type value 
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread limit type
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    type : "Dimension", "Support Depth" or "Up To Plane"
 
     int get_thread_limit_type          (DTK_THREAD_LIMIT_TYPE&);
     Dtk_string GetLimitTypeAsString() const;
     DTK_THREAD_LIMIT_TYPE GetLimitType() const {return thread_limit_type;}
 
     //! \brief     Returns the thread limit reference plane if exists
     //! \param [in]     Inner Thread feature
     //! \param [in/out]
     //! \param [out]    Thread limit plane if exists or NULL
     //! \return    NOTOK if error, ISOK if ok
     //! \remark Available only if thread limit type is "Up To Plane"
 
     int get_thread_limit_reference          (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetLimitReference() const {return thread_limit_reference;}
 
} ;
 
 
/**
@brief Feature Thread (taraudage) 
*/
class Dtk_feat_thread {
 
public:
 
     Dtk_feat_geometry   *    face_limit;
 
     Dtk_feat_geometry   *    support;
 
     double                   support_diameter;
     Dtk_feat_tolerance_set   *    tol_support_diameter;
     double                   support_depth;
     Dtk_feat_tolerance_set   *    tol_support_depth;
 
     Bool                     direction_reversed;
 
     Dtk_feat_inner_thread    *    inner_thread;
 
public :
 
 
     //! \brief     Constructor of Thread Feature      
     //! \param [in/out] 
     //! \param [out]    Allocated thread feature  
     //! \return    
     //! \remark
 
     Dtk_feat_thread ();
 
     //! \brief     Desstructor of Thread Feature      
     //! \param [in/out] 
     //! \param [out]    Free Thread feature  
     //! \return    
     //! \remark
 
     ~Dtk_feat_thread ();
 
     //! \brief     Returns the inner thread parameters
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Inner thread feature
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    The inner thread contains several parameters such as thread diameter, depth, type... See Dtk_feat_inner_thread for more details.
 
     int get_inner_thread                                   (Dtk_feat_inner_thread **);
     Dtk_feat_inner_thread *GetInnerThread()const{return inner_thread;}
 
     //! \brief     Returns the thread support surface
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Support surface
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int  get_support                        (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetSupport()const{return support;}
          
 
     //! \brief     Returns the thread support surface depth
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Support surface depth
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_support_depth                                  (double *);
     Dtk_Double64 GetSupportDepth() const{return support_depth;}
 
     //! \brief     Returns the thread support surface depth with tolerance values if any
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Support surface depth & tolerances if any
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the support depth with get_depth_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_support_depth_with_tol                         (double *, double *, double *);
     Dtk_feat_tolerance_set *GetSupportDepthTolerance() const{return tol_support_depth;}
 
     //! \brief     Tests whether there is a tolerance set on support depth
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_support_depth_has_tol                     (Bool *);
     Dtk_bool HasSupportDepthTolerance() const{return !(tol_support_depth == NULL);}
 
     //! \brief     Returns the thread support surface diameter
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Support surface diameter
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_support_diameter                          (double *);
     Dtk_Double64 GetSupportDiameter() const{return support_diameter;}
 
     //! \brief     Returns the thread support surface diameter with tolerance values if any
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Support surface diameter & tolerances if any
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the support diameter with get_diameter_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_support_diameter_with_tol                 (double *, double *, double *);
     Dtk_feat_tolerance_set *GetSupportDiameterTolerance() const{return tol_support_diameter;}
 
     //! \brief     Tests whether there is a tolerance set on support diameter
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_support_diameter_has_tol                  (Bool *);
     Dtk_bool HasSupportDiameterTolerance() const{return !(tol_support_diameter == NULL);}
 
     //! \brief     Returns thread limit surface
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Thread limit surface
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    
 
     int  get_limit                                         (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetLimit()const{return face_limit;}
 
     //! \brief     Returns thread direction reversed
     //! \param [in]     Thread feature
     //! \param [in/out]
     //! \param [out]    Direction reversed flag
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_direction_reversed                             (Bool *);
     Dtk_bool IsReversed()const{return direction_reversed;}
 
} ;
 
/* End Feature Thread */
 
 
/**
@brief  Hole Feature : position, direction, type, diameter, anchorpoint of hole feature. 
*/
class Dtk_feat_hole {
 
public:
 
     Dtk_hole_params                    hole_params;
     Dtk_feat_tolerance_set   *    tol_hole[3];
     Dtk_feat_axis            *         axis;
     Dtk_feat_limit           *    hole_limit;
     HOLE_BOTTOM_TYPE    hole_bottom_type;
     HOLE_TYPE           hole_type;
     Dtk_counter_params            counter_params;
     Dtk_Double64 Sunk_diameter;//When type = COUNTER_DRILLED_2,find Bore diameter in counter_params[2] Needed for Pro/E
     Dtk_feat_tolerance_set   *    tol_counter[3];
     ANCHOR_TYPE              anchor_type;
     Bool                hole_threaded;
     Dtk_feat_inner_thread              *    thread;
     Dtk_feat_geometry        *    sketch;
     Dtk_feat_geometry        *    support;
     Dtk_feat_geometry        *    limit;
     Dtk_feat_geometry        *    direction;
     Dtk_feat_sketch * feat_sketch;
     Dtk_pnt anchor;
     char  *dimension_tolerance;
     Dtk_Int32           start_active;
     Dtk_hole_params         start_params;
     Dtk_Int32           relief_active;
     Dtk_hole_params          relief_params;
     Dtk_Int32           neck_active;
     Dtk_hole_params          neck_params;
     Dtk_Int32           end_active;
     Dtk_hole_params          end_params;
 
 
public :
 
 
     //! \brief     Constructor of Hole Feature        
     //! \param [in/out]
     //! \param [out]    Allocated hole feature  
     //! \return    
     //! \remark
 
     Dtk_feat_hole();
 
     //! \brief     Destructor of a hole feature   
     //! \param [in]     Hole feature to destruct
     //! \param [in/out]
     //! \param [out]    Free Hole Feature   
     //! \return    
     //! \remark
 
     ~Dtk_feat_hole();
 
 
     //! \brief     Gets the hole type   
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole Type
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_type             (HOLE_TYPE *);
     HOLE_TYPE GetType() const {return hole_type;}
     Dtk_string GetTypeAsString() const;
 
     //! \brief     Gets the hole anchor type if any
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole Anchor Type
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You should test hole type before
 
     int  get_anchor_type     (ANCHOR_TYPE *);
     Dtk_string GetAnchorTypeAsString() const;
 
     //! \brief     Gets the hole bottom type if any
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole Bottom Type :
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int  get_bottom_type     (HOLE_BOTTOM_TYPE *);
     Dtk_string GetThreadBottomTypeAsString() const;
 
     //! \brief     Tests whether the hole is threaded or not 
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_threaded         (Bool *);
     Dtk_bool IsThreaded()const {return hole_threaded;}
 
     //! \brief     Returns the inner thread if any
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Inner Thread
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You should test if the hole is threaded before by get_threaded
 
     int get_inner_thread     (Dtk_feat_inner_thread **);
     Dtk_feat_inner_thread *GetInnerThread() const {return thread;}
 
     Dtk_feat_geometry *GetSketch()const {return sketch;}
     Dtk_feat_geometry *GetSupport()const {return support;}
 
     //! \brief     Returns the hole axis
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Axis
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int  get_axis            (Dtk_feat_axis **);
     Dtk_feat_axis *GetAxis() const {return axis;}
 
     //! \brief     Returns the hole limit
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole limit
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int  get_limit           (Dtk_feat_limit **);
     Dtk_feat_limit *GetLimit() const {return hole_limit;}
 
     //! \brief     Returns the hole diameter
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole diameter
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int  get_diameter        (double *);
     Dtk_Double64 GetDiameter() const {return  hole_params[IND_DIAMETER];}
 
     //! \brief     Gets the hole diameter with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Diameter, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the diameter with get_diameter_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_diameter_with_tol     (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDiameterTolerance() const {return tol_hole[IND_DIAMETER]; }
 
 
     //! \brief     Tests whether there is a tolerance set on diameter
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_diameter_has_tol (Bool *);
     Dtk_bool HasDiameterTolerance()const {return !(tol_hole[IND_DIAMETER] == NULL);}
 
     //! \brief     Returns the hole depth
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole depth
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_depth            (double *);
     Dtk_Double64 GetDepth() const {return  hole_params[IND_DEPTH];}
 
     //! \brief     Gets the hole depth with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Depth, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the depth with get_depth_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_depth_with_tol   (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDepthTolerance() const {return tol_hole[IND_DEPTH]; }
 
 
     //! \brief     Tests whether there is a tolerance set on depth
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_depth_has_tol    (Bool *);
     Dtk_bool HasDepthTolerance()const {return !(tol_hole[IND_DEPTH] == NULL);}
 
     //! \brief     Returns the hole bottom angle
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole bottom angle
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    Used for V-Bottom holes. In other cases, you shoud obtain a 0.0 value. You should test hole type before.
 
     int get_bottom_angle     (double *);
     Dtk_Double64 GetBottomAngle() const {return  hole_params[IND_ANGLE];}
 
 
     //! \brief     Gets the hole bottom angle with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bottom Angle, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the bottom angle with get_bottom_angle_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_bottom_angle_with_tol (double *, double *, double *);
     Dtk_feat_tolerance_set *GetBottomAngleTolerance() const {return tol_hole[IND_ANGLE]; }
 
     //! \brief     Tests whether there is a tolerance set on bottom angle
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_bottom_angle_has_tol  (Bool *);
     Dtk_bool HasBottomAngleTolerance()const {return !(tol_hole[IND_ANGLE] == NULL);}
 
     //! \brief     Returns the hole counter diameter
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole counter diameter
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_diameter ( double *);
     Dtk_Double64 GetCounterDiameter() const {return  counter_params[IND_DIAMETER];}
 
 
     //! \brief     Returns the hole counter diameter
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole sunk diameter (when type is COUNTER_DRILLED_2)
     //! \return    NOTOK if error, ISOK if ok
     //! \remark Find Bore diameter in counter_params[2] (get_counter_diameter)
 
     int get_sunk_diameter ( double *);
     Dtk_Double64 GetSunkDiameter() const {return  Sunk_diameter;}
 
     //! \brief     Gets the hole counter diameter with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Counter Diameter, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the counter diameter with get_dtk_feat_hole_counter_diameter_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_counter_diameter_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterDiameterTolerance() const {return tol_counter[IND_DIAMETER]; }
 
 
     //! \brief     Tests whether there is a tolerance set on counter diameter
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_diameter_has_tol   (Bool *);
     Dtk_bool HasCounterDiameterTolerance()const {return !(tol_counter[IND_DIAMETER] == NULL);}
 
 
     //! \brief     Returns the hole counter depth
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole counter depth
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_depth ( double *);
     Dtk_Double64 GetCounterDepth() const {return  counter_params[IND_DEPTH];}
 
     //! \brief     Gets the hole counter depth with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Counter Depth, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the counter depth with get_dtk_feat_hole_counter_depth_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_counter_depth_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterDepthTolerance() const {return tol_counter[IND_DEPTH]; }
 
     //! \brief     Tests whether there is a tolerance set on counter depth
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_depth_has_tol (Bool *);
     Dtk_bool HasCounterDepthTolerance()const {return !(tol_counter[IND_DEPTH] == NULL);}
 
 
     //! \brief     Returns the hole counter angle
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Hole counter angle
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_angle ( double *);
     Dtk_Double64 GetCounterAngle() const {return  counter_params[IND_ANGLE];}
 
     //! \brief     Gets the hole counter angle with its tolerance value (inf value & sup value)
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Counter Depth, Inf Value, Sup Value
     //! \return    NOTOK if error, ISOK if ok
     //! \remark    You have to test if there is a tolerance on the counter angle with get_angle_has_tol. In case of direct call and no tolerance set, you should obtain a NOTOK status
 
     int get_counter_angle_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterAngleTolerance() const {return tol_counter[IND_ANGLE]; }
 
 
     //! \brief     Tests whether there is a tolerance set on counter angle
     //! \param [in]     Hole feature
     //! \param [in/out]
     //! \param [out]    Bool
     //! \return    NOTOK if error, ISOK if ok
     //! \remark
 
     int get_counter_angle_has_tol (Bool *);
     Dtk_bool HasCounterAngleTolerance()const {return !(tol_counter[IND_ANGLE] == NULL);}
 
     int get_annotation ( Dtk_pnt *, char *);
 
     //! \brief     test if start chamfer is activated
     //! \return    DTK_TRUE if activate, if not DTK_FALSE
     //! \remark
     Dtk_Int32 IsStartActived() const {return start_active;}
 
     //! \brief     return the angle of the start chamfer
     //! \return    the angle value
     //! \remark
     Dtk_Double64 GetStartAngle() const {return  start_params[IND_ANGLE];}
 
     //! \brief     return the diameter of the start chamfer
     //! \return    the diameter value
     //! \remark
     Dtk_Double64 GetStartDiameter() const {return  start_params[IND_DIAMETER];}
 
 
     //! \image html feat_img_relief.png
     //! \brief     test if relief is activated , only relief or neck can be activated not both
     //! \return    DTK_TRUE if activate, if not DTK_FALSE
     //! \remark
     Dtk_Int32 IsReliefActived() const {return relief_active;}
 
     //! \brief     return the angle of the relief
     //! \return    the angle value
     //! \remark
     Dtk_Double64 GetReliefAngle() const {return  relief_params[IND_ANGLE];}
 
     //! \brief     return the diameter of the relief
     //! \return    the diameter value
     //! \remark
     Dtk_Double64 GetReliefDiameter() const {return  relief_params[IND_DIAMETER];}
 
     //! \brief     return the depth of the relief
     //! \return    the depth value
     //! \remark
     Dtk_Double64 GetReliefDepth() const {return  relief_params[IND_DEPTH];}
 
     //! \image html feat_img_neck.png
     //! \brief     test if neck is activated , only neck or relief can be activated not both
     //! \return    DTK_TRUE if activate, if not DTK_FALSE
     //! \remark
     Dtk_Int32 IsNeckActived() const {return neck_active;}
 
     //! \brief     return the angle of the neck
     //! \return    the angle value
     //! \remark
     Dtk_Double64 GetNeckAngle() const {return  neck_params[IND_ANGLE];}
 
     //! \brief     return the diameter of the neck
     //! \return    the diameter value
     //! \remark
     Dtk_Double64 GetNeckDiameter() const {return  neck_params[IND_DIAMETER];}
 
     //! \brief     return the depth of the neck
     //! \return    the depth value
     //! \remark
     Dtk_Double64 GetNeckDepth() const {return  neck_params[IND_DEPTH];}
 
     //! \brief     test if end chamfer is activated
     //! \return    DTK_TRUE if activate, if not DTK_FALSE
     //! \remark
     Dtk_Int32 IsEndActived() const {return end_active;}    
     
     //! \brief     return the angle of the end chamfer
     //! \return    the angle value
     //! \remark
     Dtk_Double64 GetEndAngle() const {return  end_params[IND_ANGLE];}
 
     //! \brief     return the diameter of the end chamfer
     //! \return    the diameter value
     //! \remark
     Dtk_Double64 GetEndDiameter() const {return  end_params[IND_DIAMETER];}
 
} ;
/* Fin Feature hole */
 
 
/**
@brief  Hole Feature : position, direction, type, diameter, anchorpoint of hole feature. 
*/
class Dtk_feat_hole_series {
 
public:
 
     Dtk_FeaturePtr          _Start ;
     Dtk_FeaturePtr          _Middle ;
     Dtk_FeaturePtr          _End ;
 
public :
 
 
     //! \brief     Constructor of Hole Feature        
     //! \param [in/out]
     //! \param [out]    Allocated hole feature  
     //! \return    
     //! \remark
 
     Dtk_feat_hole_series();
 
     //! \brief     Destructor of a hole feature   
     //! \param [in]     Hole feature to destruct
     //! \param [in/out]
     //! \param [out]    Free Hole Feature   
     //! \return    
     //! \remark
 
     ~Dtk_feat_hole_series();
 
     //! \brief     Gets the hole start 
     //! \param [in]     Hole Series feature
     //! \param [in/out] Hole feature
     //! \remark    You should test hole type before
     void get_dtk_feat_hole_series_start     (Dtk_FeaturePtr& out);
 
     //! \brief     Gets the hole middle
     //! \param [in]     Hole Series feature
     //! \param [in/out] Hole feature
     //! \remark    You should test hole type before
     void get_dtk_feat_hole_series_middle    (Dtk_FeaturePtr& out);
 
     //! \brief     Gets the hole end
     //! \param [in]     Hole Series feature
     //! \param [in/out] Hole feature
     //! \remark    You should test hole type before
     void get_dtk_feat_hole_series_end       (Dtk_FeaturePtr& out);
     
 
 
} ;
/* Fin Feature hole */
 
/**
@brief  Dtk_feat_udf : _Hole, _XmlDefinition of feature. 
*/
class Dtk_feat_udf {
 
public:
 
     Dtk_FeaturePtr          _Feature ;
     Dtk_string              _XmlDefinition ;
 
public :
 
 
     //! \brief     Constructor of Dtk_feat_udf        
     //! \param [in/out]
     //! \param [out]    Allocated hole feature  
     //! \return    
     //! \remark
 
     Dtk_feat_udf();
 
     //! \brief     Destructor of a Dtk_feat_udf  
     //! \param [in]     Hole feature to destruct
     //! \param [in/out]
     //! \param [out]    Free Hole Feature   
     //! \return    
     //! \remark
 
     ~Dtk_feat_udf();
 
     //! \brief     Gets the hole  
     //! \param [in]     Dtk_feat_udf feature
     //! \param [in/out] Hole feature
     //! \remark    You should test hole type before
     void get_dtk_feat_udf_feature (Dtk_FeaturePtr& out);
 
     //! \brief     Gets the xml definition
     //! \param [in]     Dtk_feat_hole_udf feature
     //! \param [in/out] stream of xml file
     //! \remark    You should test hole type before
     void get_dtk_feat_udf_xmldefinition(Dtk_string& out);
 
} ;
/* Fin Feature hole */
 
/**
@brief  Shell Feature : a shell feature is defined with a list of faces corresponding to its opening and two offset values. 
*/
class Dtk_feat_shell {
 
public:
 
     Dtk_feat_shell_face **   skins;
     Dtk_feat_shell_face **   removed_faces;
     double                   default_inside_thickness;
     double                   default_outside_thickness;
     int                      nb_removed_faces;
     int                      nb_skins;
 
 
     //! \brief     Constructor of Shell Feature       
     //! \param [in/out]
     //! \param [out]    Allocated shell feature  
     //! \return    
     //! \remark
 
     Dtk_feat_shell ();
 
     //! \brief     Destructor of a shell feature 
     //! \param [in]   shell feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Shell Feature  
     //! \remark
 
     ~Dtk_feat_shell();
 
     //! \brief     Get the inner thickness value of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   double 
     //! \return    INNER Thickness value of Shell Feature  
     //! \remark
 
     int get_inside_thickness ( double *);
 
     //! \brief     Get the outside thickness value of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   double 
     //! \return    OUTER Thickness value of Shell Feature  
     //! \remark
 
     int get_outside_thickness ( double *); 
 
     //! \brief     Get the number of removed faces of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   int 
     //! \return    Number of removed faces of Shell Feature  
     //! \remark
 
     int get_nb_removed_faces ( int *);
 
     //! \brief     Get the number of skins of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   int 
     //! \return    Number of skins of Shell Feature  
     //! \remark
 
     int get_nb_skins ( int *);
 
     //! \brief     Get the removed faces of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_shell_face 
     //! \return    removed faces of Shell Feature  
     //! \remark
 
     int get_removed_faces ( Dtk_feat_shell_face*** );
 
     //! \brief     Get the skins of the feature Shell 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_shell_face
     //! \return    skins of Shell Feature  
     //! \remark
 
     int get_skins ( Dtk_feat_shell_face*** );
 
} ;
 
/* End feature Shell */
 
/**
@brief Feature Constant Radius Edge Ribbon
*/
class Dtk_feat_cst_edge_ribbon {
public:
 
     double                   cst_radius;
 
     Dtk_feat_cst_edge_ribbon();
     ~Dtk_feat_cst_edge_ribbon();
 
     //! \brief   Returns constant edge ribbon radius                                          
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   double
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_radius (double *);
 
} ;
 
/**
@brief Fillet point
*/
class Dtk_feat_fillet_point {
 
public:
 
     Dtk_pnt                       point;
     double                        radius;
     double                        ratio;
 
     DTK_POINT_CONSTRUCTION        point_construction; /* debug info */
     long                     construct_geom;
 
     Dtk_feat_geometry   *    elt; /* elt = parent edge if on_edge = DTK_TRUE
                                         geometric ID if on_edge = DTK_FALSE */
 
     Dtk_feat_fillet_point();
     ~Dtk_feat_fillet_point ();
 
     //! \brief   Returns fillet point element                                         
     //! \param [in]   Fillet point                                              
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_elt ( Dtk_feat_geometry **);
 
     //! \brief   Returns fillet point                                          
     //! \param [in]   Fillet point                                              
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_point ( Dtk_pnt*);
 
     //! \brief   Returns fillet point radius                                         
     //! \param [in]   Fillet point                                              
     //! \param [in/out]                                                   
     //! \param [out]   double 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_radius ( double *);
 
     //! \brief   Returns fillet point ratio on attached edge                                       
     //! \param [in]   Fillet point                                              
     //! \param [in/out]                                                   
     //! \param [out]   double 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_ratio ( double *);
 
 
 
} ;
 
/**
@brief Feature Variable Radius Edge Ribbon 
*/
class Dtk_feat_var_edge_ribbon {
public:
 
     Dtk_feat_fillet_point**  points;
     int                      nb_points;
 
     FILLET_VARIATION_TYPE    variation;
 
     Dtk_feat_var_edge_ribbon();
     ~Dtk_feat_var_edge_ribbon();
 
     //! \brief   Returns constant edge ribbon points number                                         
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   double
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_nb_points ( int *);
 
     //! \brief   Returns variable edge ribbon set of points                                         
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_fillet_point**
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_points ( Dtk_feat_fillet_point***);
     int get_variation (FILLET_VARIATION_TYPE *);
 
};
 
 
 
/**
@brief Feature Edge Ribbon 
*/
class Dtk_feat_edge_ribbon {
 
public:
 
     
 
     union edge_ribbon_type {
          Dtk_feat_cst_edge_ribbon *    cst;
          Dtk_feat_var_edge_ribbon *    var;
     } ribbon;
 
     
     Dtk_feat_geometry   *    ribbon_spine;
     Dtk_feat_geometry   **   elts;
     Dtk_feat_geometry   **   kept_edges;
 
     int                      nb_kept_edges;
     int                           nb_elts;
     PROPAGATION_TYPE    propagation;
     Bool                spine;
 
     FILLET_TYPE              ribbon_type;
 
     Dtk_feat_edge_ribbon();
     ~Dtk_feat_edge_ribbon();
 
    //! \brief OBSOLETE Returns edge ribbon propagation as Bool
    //! \param [out]   Bool: Asked PropagationType.
    //! \return     DTK_NOTOK if error, DTK_ISOK if ok
    //! \deprecated Use GetPropagationType() const method instead.
     SetAsDeprecated("Undefined", "Use GetPropagationType")
     int  get_propagation ( Bool *); 
 
    //! \brief Returns the edge ribbon propagation type.
    //! \return     Asked Propagation type as PROPAGATION_TYPE enum
    PROPAGATION_TYPE GetPropagationType() const;
 
     //! \brief   Returns edge ribbon elements                                           
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_elts ( Dtk_feat_geometry** *);
 
     //! \brief   Returns edge ribbon elements number                                           
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   int
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_elts ( int *);
 
     //! \brief   Returns edge constant ribbon                                            
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_cst_edge_ribbon
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_cst_ribbon (Dtk_feat_cst_edge_ribbon**);
 
     //! \brief   Returns edge variable ribbon                                            
     //! \param [in]   Ribbon                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_var_edge_ribbon
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_var_ribbon (Dtk_feat_var_edge_ribbon**);
 
 
 
 
} ;
 
 
/**
@brief    Feature Blend Corner (pour les conges)
*/
class Dtk_feat_blend_vertex {
 
public:
 
     Dtk_feat_geometry        *    corner;
     double                        set_back_distance;
 
     Dtk_feat_blend_vertex();
     ~Dtk_feat_blend_vertex();
 
     //! \brief   Returns corner of blend vertex                                         
     //! \param [in]   Blend vertex                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_corner ( Dtk_feat_geometry **);
 
     //! \brief   Returns back distance of blend vertex                                         
     //! \param [in]   Blend vertex                                               
     //! \param [in/out]                                                   
     //! \param [out]   double 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_set_back_distance ( double*);
 
} ;
 
 
 
/**
@brief Generic Feature Fillet
*/
class Dtk_feat_fillet {
 
public:
          
     Dtk_feat_edge_ribbon**   objects_to_fillet;
     Dtk_feat_blend_vertex**  corners;
     Dtk_feat_geometry   **   limiting_list;
     int                      nb_limits;
     int                      nb_objects_to_fillet;
     int                      nb_corners;
     Bool                trim_ribbon_mode;
     FILLET_TYPE              type;
     PROPAGATION_TYPE    propagation;
 
     Dtk_feat_fillet ();
     ~Dtk_feat_fillet ();
 
     //! \brief   Returns Fillet type                                               
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   FILLET_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_type ( FILLET_TYPE *);
 
     //! \brief   Returns Fillet propagation                                               
     //! \param [in]   Fillet  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   PROPAGATION_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_propagation ( PROPAGATION_TYPE *);
 
     //! \brief   Returns Fillet edge ribbon number                                               
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   int                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_nb_objects_to_fillet ( int *);
 
     //! \brief   Returns Fillet limits number                                               
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   int                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_nb_limits ( int *) ;
 
     //! \brief   Returns Fillet corners number                                               
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   int                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_nb_corners ( int *);
 
     //! \brief   Returns Fillet corners                                              
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_blend_vertex                      
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_corners ( Dtk_feat_blend_vertex** *);
 
     //! \brief   Returns Fillet limiting list                                              
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_limiting_list ( Dtk_feat_geometry** *);
 
     //! \brief   Returns Fillet ribbon objects                                              
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_edge_ribbon        
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_objects_to_fillet ( Dtk_feat_edge_ribbon** *);
 
     //! \brief   Returns Fillet trim ribbon mode                                              
     //! \param [in]   Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool         
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_trim_ribbon_mode ( Bool *);
 
 
};
 
 
/**
@brief Generic Feature Face Fillet
*/
class Dtk_feat_face_fillet {
 
public:
 
     double                                  radius; 
     Dtk_feat_geometry*                 face1; 
     Dtk_feat_geometry*                 face2; 
 
     Dtk_feat_geometry*                 limitingElement; 
     Dtk_feat_geometry*                 holdCurve; 
     Dtk_feat_geometry*                 spine; 
 
     Dtk_feat_face_fillet ();
     ~Dtk_feat_face_fillet ();
 
 
     //! \brief   Returns Face Fillet radius                                               
     //! \param [in]   Face Fillet Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   double                                                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_radius ( double *);
 
 
     //! \brief   Returns First face element to Fillet 
     //! \param [in]   Face Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry*          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_face1 ( Dtk_feat_geometry**);
 
 
 
     //! \brief   Returns Second face element to Fillet 
     //! \param [in]   Face Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry*          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_face2 ( Dtk_feat_geometry**);
 
 
 
     //! \brief   Returns Face Fillet limiting element                                              
     //! \param [in]   Face Fillet Feature                                             
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_limiting_element ( Dtk_feat_geometry**);
 
 
     //! \brief   Returns Face Fillet hold curve                                              
     //! \param [in]   Face Fillet Feature                                             
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_hold_curve ( Dtk_feat_geometry**);
 
 
 
     //! \brief   Returns Face Fillet spine                                            
     //! \param [in]   Face Fillet Feature                                             
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_spine ( Dtk_feat_geometry**);
 
};
 
 
/**
@brief Generic Feature Face Fillet
*/
class Dtk_feat_tritangent_fillet {
 
public:
 
     Dtk_feat_geometry*                 face1; 
     Dtk_feat_geometry*                 face2; 
     Dtk_feat_geometry*                 faceToRemove; 
     Dtk_feat_geometry*                 limitingElement; 
 
     Dtk_feat_tritangent_fillet ();
     ~Dtk_feat_tritangent_fillet ();
 
 
 
     //! \brief   Returns First face element to tri-tangent Fillet 
     //! \param [in]   Tri-tangent Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry*          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_face1 ( Dtk_feat_geometry**);
 
 
 
     //! \brief   Returns Second face element to tri-tangent Fillet 
     //! \param [in]   Tri-tangent Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry*          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_face2 ( Dtk_feat_geometry**);
 
 
     //! \brief   Returns Removed face element to tri-tangent Fillet 
     //! \param [in]   Tri-tangent Fillet Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry*          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_remove_face ( Dtk_feat_geometry**);
 
 
 
     //! \brief   Returns tri-tangent Fillet limiting element                                              
     //! \param [in]   Tri-tangent Fillet Feature                                             
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_limiting_element ( Dtk_feat_geometry**);
 
};
 
 
 
/**
@brief    Feature Sweep (Rib & Slot)
*/
class Dtk_feat_sweep {
 
public:
 
     
 
     
 
     Dtk_feat_geometry        **   profiles;
     Dtk_feat_thickness       *    thickness;
     Dtk_feat_geometry        *    center_curve;
     Dtk_feat_axis            *    axis;
     union {
          Dtk_feat_geometry        *    selection;
          Dtk_feat_axis            *    axis;
     } control_object;
 
     int                                nb_profiles;
     Bool                          merge_sweep_ends;
     PROFILE_CONTROL_TYPE          profile_control_type;
     DTK_SWEEP_TYPE                sweep_type;
     
 
     Dtk_feat_sweep ();
     ~Dtk_feat_sweep();
 
     //! \brief   Returns Sweep type                                               
     //! \param [in]   Sweep Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   DTK_SWEEP_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_type ( DTK_SWEEP_TYPE *);
 
     //! \brief   Returns thickness of a sweep.                                                
     //! \param [in]   Sweep Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_thickness (the internal and external thickness)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_thickness ( Dtk_feat_thickness **); 
 
     //! \brief   Returns Sweep profiles number                                               
     //! \param [in]   Sweep Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   int                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_nb_profiles ( int *); 
 
     //! \brief     Get the profiles geometry of the feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_geometry
     //! \return    profiles geometry of Sweep Feature  
     //! \remark 
 
     int get_profiles ( Dtk_feat_geometry *** ); 
 
     //! \brief     Get the center curve of the feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_feat_geometry
     //! \return    center curve geometry of Sweep Feature  
     //! \remark
 
     int get_center_curve ( Dtk_feat_geometry ** ); 
 
     //! \brief     Get the boolean value of merge sweep ends of the feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]   Bool
     //! \return    boolean value of merge sweep ends of Sweep Feature  
     //! \remark 
 
     int get_merge_ends ( Bool * ); 
 
     //! \brief     Get the profile control type of the feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]    PROFILE_CONTROL_TYPE
     //! \return    profile control type of Sweep Feature  
     //! \remark
 
     int get_profile_control_type ( PROFILE_CONTROL_TYPE * ); 
 
     //! \brief     Get axis of the feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]    Dtk_feat_axis 
     //! \return    Axis of Sweep Feature  
     //! \remark
 
     int get_axis ( Dtk_feat_axis ** );
 
     //! \brief     Get selection control object of feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]    Dtk_feat_geometry 
     //! \return    selection control object of Sweep Feature  
     //! \remark
 
     int get_control_object_selection ( Dtk_feat_geometry ** );
 
     //! \brief     Get axis control object of feature Sweep 
     //! \param [in]   Sweep feature   
     //! \param [in/out]     
     //! \param [out]    Dtk_feat_axis
     //! \return    axis control object of Sweep Feature  
     //! \remark
 
     int get_control_object_axis ( Dtk_feat_axis ** ); 
} ;
 
 
 
/**
@brief Generic Split Surface 
*/ 
 
class Dtk_feat_split_surf {
public: 
     Dtk_feat_geometry   *              splitting_element;
     /*@brief The side value is either PositiveSide (=0) when it refers to 
     the same orientation as the surfacic feature normal vector or 
     NegativeSide (=1) when it refers to the opposite orientation as the 
     surfacic feature normal vector. */
     Bool                               side;
 
     Dtk_feat_split_surf(); 
     ~Dtk_feat_split_surf(); 
 
 
 
     //! \brief   Returns the splitting surface element of the feature                                                 
     //! \param [in]   Split Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry *                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_split_element  (Dtk_feat_geometry* *);
 
 
     //! \brief   Returns the side indicating the portion of the body to be kept 
     //! \param [in]   Split Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Bool                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_side  (Bool *);
};
 
 
/**
@brief Generic Thick Surface 
*/ 
class Dtk_feat_thick_surf {
public: 
 
     Dtk_feat_geometry   *              surface;
     double                                  first_offset;
     double                                  second_offset;
     Bool                               sens_offset;
 
     Dtk_feat_thick_surf(); 
     ~Dtk_feat_thick_surf(); 
 
 
     //! \brief   Returns the thickened surface element of the feature                                                 
     //! \param [in]   Thick Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry *                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_surface  (Dtk_feat_geometry* *);
 
 
     //! \brief   Returns the first offset of the thickness surface 
     //! \param [in]   Thick Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    double                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_first_offset  (double *);
 
 
     //! \brief   Returns the second offset of the thickness surface 
     //! \param [in]   Thick Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    double                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_second_offset  (double *);
 
 
 
     //! \brief   Returns the reverse direction boolean value  
     //! \param [in]   Thick Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Bool                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_sens_offset (Bool *);
}; 
 
 
/**
@brief Generic Sew Surface 
*/  
class Dtk_feat_sew_surf {
public: 
 
     Dtk_feat_split_surf *              split;
     int                                     intersect_mode;
     int                                     simplify_mode;
 
     Dtk_feat_sew_surf(); 
     ~Dtk_feat_sew_surf(); 
};
 
 
/**
@brief Generic Close Surface 
*/ 
class Dtk_feat_close_surf {
 
public: 
 
     Dtk_feat_geometry        *         surf;
     double                                  tolerance;
 
     Dtk_feat_close_surf(); 
     ~Dtk_feat_close_surf(); 
 
 
     //! \brief   Returns the closed surface element of the feature                                                 
     //! \param [in]   Close Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry *                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_surface  (Dtk_feat_geometry* *);
 
 
 
     //! \brief   Returns the tolerance of the close surface feature
     //! \param [in]   Close Surface  Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    double                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_tolerance  (double *);
 
};
 
/**
@brief Generic Remove Face 
*/ 
class Dtk_feat_remove_face {
 
public: 
 
     Dtk_tab <Dtk_feat_geometry*>       faces_to_remove; 
     Dtk_tab <Dtk_feat_geometry*>       faces_to_keep; 
 
 
     //! \brief   Constructor of Remove Face Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Allocated Remove Face feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     Dtk_feat_remove_face(); 
 
 
 
     //! \brief     Destructor of a Remove Face Feature 
     //! \param [in]   Remove Face Feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Remove Face Feature  
     //! \remark           
 
 
     ~Dtk_feat_remove_face(); 
 
 
     //! \brief   Returns the array of faces to remove of the remove face feature                                                
     //! \param [in]   Remove Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_tab <Dtk_feat_geometry *>                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_faces_to_remove (Dtk_tab <Dtk_feat_geometry*>& );
 
 
     //! \brief   Returns the array of faces to keep of the remove face feature                                                
     //! \param [in]   Remove Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_tab <Dtk_feat_geometry *>                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_faces_to_keep (Dtk_tab <Dtk_feat_geometry*>& );
 
 
 
     //! \brief   Returns the number of faces to remove of the Remove Face feature                                                
     //! \param [in]   Remove Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    int                                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_removed_faces_nb (int*);
 
 
     //! \brief   Returns the number of faces to keep of the Remove Face feature                                                
     //! \param [in]   Remove Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    int                                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_kept_faces_nb (int*);
 
};
 
 
/**
@brief Generic Replace Face 
*/ 
class Dtk_feat_replace_face {
 
public: 
 
     Dtk_feat_geometry*       face_to_remove; 
     Dtk_feat_geometry*       replacing_surface; 
 
 
 
     //! \brief   Constructor of Replace Face Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Allocated Replace Face feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     Dtk_feat_replace_face(); 
 
 
 
     //! \brief     Destructor of a Replace Face Feature 
     //! \param [in]   Replace Face Feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Replace Face Feature  
     //! \remark           
 
 
     ~Dtk_feat_replace_face(); 
 
 
     //! \brief   Returns the face to remove of the replace face feature                                                
     //! \param [in]   Replace Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry                                                                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_face_to_remove (Dtk_feat_geometry**);
 
 
     //! \brief   Returns the replacing surface geometry of the Replace Face feature                                                
     //! \param [in]   Replace Face Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry *                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
     int get_replacing_surface (Dtk_feat_geometry**);
 
};
 
 
class Dtk_feat_pattern_dir {
 
public:
 
     
     Dtk_feat_axis            *         direction;
     double                                  length;
     double                                  spacing;
     int                                     nb_instances;
     
     //   Dtk_feat_geometry        *         direction_geom;
     Bool                               reverse;
     Dtk_bool                           isEqualSpacing; 
     Dtk_tab	<double>                   tabInstanceSpacingValues; 
 
     Dtk_feat_pattern_dir();
     ~Dtk_feat_pattern_dir();
 
 
 
     //! \brief   Returns Number of occurrences in this pattern direction (including the base feature to repeat)                                                 
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]  int                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_nb_instances  (int *);
 
 
 
     //! \brief   Returns the distance between two consecutive occurrences                                                  
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]  int                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_spacing  (double *);
 
 
 
     //! \brief   Returns the length of the pattern, I.E, the distance between the first and the last occurrence.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]  double                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    For Circular pattern: The length is the total angle of the circular pattern. Total Angle =     Spacing * (nb_instances - 1);           
 
     int get_length   (double *);
 
 
 
     //! \brief   Returns the axis of direction for pattern feature.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_axis*                                                                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_direction   (Dtk_feat_axis **);
 
 
     //! \brief   Returns the boolean value for the reverse status of the pattern direction.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Bool                                                                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_reverse   (Bool *);
 
     //! \brief   Returns the boolean value to check if instances are equal spacing.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_Bool                                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
     int get_is_equal_spacing ( Dtk_bool * );
     
     //! \brief   Returns the list of unequal spacing values ( available if get_is_equal_spacing returns DTK_FALSE)                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    list of double for spacing values                                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
     int get_instance_spacing_array ( Dtk_tab <double> * ); 
} ;
 
 
class Dtk_feat_rect_pattern {
public:
     Dtk_feat_pattern_dir     *         first_dir;
     Dtk_feat_pattern_dir     *         second_dir;
 
 
     Dtk_feat_rect_pattern();
     ~Dtk_feat_rect_pattern();
 
 
 
     //! \brief   Returns the first direction definition of the specified rectangular pattern feature.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_pattern_dir*                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_first_dir   (Dtk_feat_pattern_dir **);
 
 
     //! \brief   Returns the second direction definition of the specified rectangular pattern feature.                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_pattern_dir*                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_second_dir   (Dtk_feat_pattern_dir **);
 
} ;
 
 
 
class Dtk_feat_circ_pattern {
public:
     Dtk_feat_pattern_dir     *         axial_reference;
     double                                  circle_spacing;
     double                                  crown_thickness;
     //set for proe
     Dtk_Double64                       offset; //angle from the begin reference
     int                                     nb_circles;
     Bool                               radial_alignment;
 
 
 
     Dtk_feat_circ_pattern();
     ~Dtk_feat_circ_pattern();
 
 
 
 
     //! \brief   Returns the definition of the specified circular pattern feature (parameters + direction).                                             
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_pattern_dir*                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_axial_reference   (Dtk_feat_pattern_dir **);
 
 
 
     //! \brief   Returns the radial alignment defining the orientation of the  created occurrences.                                              
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Bool                                                                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_radial_alignment  (Bool *);
 
 
 
     //! \brief   Returns the number of crown created from the original circular pattern (including the base circ pattern).                                              
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    int                                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_nb_circles  (int *);
 
 
     //! \brief   Returns the distance between two consecutive circles of the crown created. 
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    double                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark         
 
     int get_circle_spacing  (double *);
 
 
     //! \brief   Returns the maximum distance allowed between the first and the last circle of a crown  (thickness of the whole crown). 
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    double                                                                     
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    Crown Thickness = ( Number Circles - 1 ) * ( Circle Spacing )    
 
     int get_crown_thickness  (double *);
 
 
} ;
 
 
 
class Dtk_feat_pattern {
public:
     union dtk_pattern_type {
          Dtk_feat_rect_pattern    *    rect;
          Dtk_feat_circ_pattern    *    circ;
     }    entity;
 
     Bool                     *         active_instances;
     Dtk_tab<Dtk_feat_geometry *>  objects_to_pattern;
     Dtk_tab<Dtk_FeaturePtr>            dtk_features;
     Dtk_tab<long>                      input_ids;
     Dtk_tab<Dtk_transfo>               objects_placement;
 
     double                                  angle;
 
     int                                     row1;
     int                                     row2;
     int                                     nb_instances;
 
     Bool                               keep_spec;
     Bool                               simple_rep;    
     bool                               gener_tool;
     DTK_PATTERN_TYPE                   type;
     DTK_OBJECT_TYPE                         object_type;   
 
     Dtk_feat_pattern();
     ~Dtk_feat_pattern();
 
 
 
 
     //! \brief   Returns pattern type                                                
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]  DTK_PATTERN_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_type  (DTK_PATTERN_TYPE *);
 
 
 
     //! \brief   Returns object type                                                
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   DTK_OBJECT_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_object_type ( DTK_OBJECT_TYPE *);
 
 
 
     //! \brief   Returns the set of objects geometry to pattern.                                                
     //! \param [in]   pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry ** (the geometry of the objects to pattern)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_objects_to_pattern ( Dtk_tab<Dtk_feat_geometry *> &); 
 
 
 
     //! \brief   Returns the number of objects to pattern.                                                
     //! \param [in]   pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_objects_to_pattern ( int *); 
 
 
 
     //! \brief   Returns the number of feature's IDs to pattern.                                                
     //! \param [in]   pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_input_ids ( int *);
 
 
 
     //! \brief   Returns the array of Feature's IDs or Body ID to pattern.                                                
     //! \param [in]   pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   long *   (Array of IDs, size = nb_input_ids)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_input_ids ( Dtk_tab<long> &);
 
 
     //! \brief   Returns the number of features resulted of the pattern feature. 
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_features ( int *);
 
 
 
     //! \brief   Returns the array of features resulted of the pattern feature. 
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat **                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> & );
 
 
 
 
     //! \brief   Returns the generated tool status indicating if generated features are to be gotten.  
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   bool                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_gener_tool ( bool *);
 
 
 
     //! \brief   Returns a boolean value indicating whether some inactive occurrences are set.  
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    The option set the ability to users to delete some occurrences of the resulted pattern. Enabling this option, and double clicking on a simple occurrence fulfill the removal of selected occurrences. 
 
     int get_simple_rep ( Bool *);
 
 
 
 
     //! \brief   Returns the number of whole instances generated by the pattern feature .  
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_instances ( int *);
 
 
     //! \brief   Returns the array of boolean values to determine an occurrence to be set active or inactive.  
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool *  (size of the array = nb_instances)                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_active_instances ( Bool **);
 
 
 
     //! \brief   Returns the order of the base feature in the list of occurrences resulted of the pattern feature.   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    For Circular Pattern : Row1 is the order according to the angular Direction For Rectangular Pattern :
     //! \remark    Row1 is the order according to the first Direction
 
     int get_row1 ( int *);
 
 
 
     //! \brief   Returns the order of the base feature in the list of occurrences resulted of the pattern feature.   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    For Circular Pattern : Row2 is the order according to the Radial Direction, viz. the order of the base circle in the crown among the set of whole circles .For Rectangular Pattern : Row2 is the order according to the second Direction
 
     int get_row2 ( int *);
 
 
 
 
     //! \brief   Returns the rotation angle specified to the pattern feature.   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   double                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    For Circular Pattern : It represents an additional distance between the base feature to pattern and the first occurrence among the repetitions. For Rectangular Pattern : It represents the angle of deviation of the pattern according to its first direction
 
     int get_angle ( double *);
 
 
 
     //! \brief   Returns the design intent of the pattern (keeping specifications).   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
 
     int get_keep_spec( Bool *);
 
 
 
     //! \brief   Returns the rectangular entity of the pattern feature.   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]  Dtk_feat_rect_pattern*                                                                                          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
 
     int get_rect_pattern ( Dtk_feat_rect_pattern **);
 
 
 
     //! \brief   Returns the circular entity of the pattern feature.   
     //! \param [in]   Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]  Dtk_feat_circ_pattern*                                                                                          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
 
     int get_circ_pattern ( Dtk_feat_circ_pattern **);
 
 
 
};
 
 
class Dtk_feat_user_pattern
{
public:
     Dtk_feat_geometry        *         object_to_pattern;  
     Dtk_feat_geometry        *         anchor_point;
     Dtk_feat_sketch *                  sketch;
 
     Dtk_tab<Dtk_FeaturePtr>            dtk_features;
     Dtk_tab<Dtk_pnt>                   points;
     Dtk_tab<long>                      input_ids;
 
     Bool                               keep_spec;
     bool                               gener_tool;
 
     DTK_OBJECT_TYPE                         object_type;
 
     Dtk_feat_user_pattern();
     ~Dtk_feat_user_pattern();
 
 
 
     //! \brief   Returns the geometry of the object to pattern to pattern.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry *                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_object_to_pattern ( Dtk_feat_geometry**); 
 
 
 
     //! \brief   Returns the design intent of the user pattern (keeping specifications).   
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
 
     int get_keep_spec( Bool *);
 
 
 
     //! \brief   Returns the anchor point of the user pattern feature.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry *                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_anchor_point  ( Dtk_feat_geometry**); 
 
 
 
     //! \brief   Returns the number of points to user pattern.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int * (number of points)                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_points ( int *); 
 
 
     //! \brief   Returns the points to user pattern.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_pnt * (Array of points)                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_points ( Dtk_tab <Dtk_pnt> &); 
 
 
     //! \brief   Returns the number of features resulted of the user pattern feature. 
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_features ( int *);
 
 
 
     //! \brief   Returns the array of features resulted of the user pattern feature. 
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat **                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> & );
 
 
 
     //! \brief   Returns the generated tool status indicating if generated features are to be gotten.  
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   bool                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_gener_tool ( bool *);
 
 
     //! \brief   Returns the number of feature's IDs to user pattern feature.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_input_ids ( int *);
 
 
 
     //! \brief   Returns the array of Feature's IDs or Body ID to user pattern feature.                                                
     //! \param [in]   User Pattern Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   long *   (Array of IDs, size = nb_input_ids)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_input_ids ( Dtk_tab <long> &);
 
 
 
} ;
 
class Dtk_feat_surface_transfo 
{
public:
     Dtk_feat_geometry*       elementGeomtry; 
     long                     elementID; 
     //bool                        hideIntitialElement; // applied directly to the affected element. 
     bool                     isSurfaceResult;
 
     Dtk_feat_surface_transfo(); 
     ~Dtk_feat_surface_transfo(); 
 
 
     //! \brief   Returns the geometry of the element to transform, i.e to translate, to rotate or to symmetry
     //! \param [in]   Dtk_feat_surface_transfo Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_element_geometry  ( Dtk_feat_geometry **);
 
 
     //! \brief   Returns the id of the element to transform, i.e to translate, to rotate or to symmetry
     //! \param [in]   Dtk_feat_surface_transfo Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   long 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_element_id  ( long*);
 
 
     //! \brief   Returns whether to hide or to show the initial element to transform 
     //! \param [in]   Dtk_feat_surface_transfo Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   1: Hide the initial Element, 0: Show the initial Element
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     //int get_hide_Intitial_Element( bool*);
 
 
     //! \brief   Returns if the result of the transormation feature is a surface or a volume. This option is available for volume elements because surface elements can result solely surface elements. 
     //! \param [in]   Dtk_feat_surface_transfo Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   1: The result element is surface, 0: The result element is Volume
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_isSurfaceResult ( bool*);
 
};
 
 
class Dtk_feat_mirror
{
public:
     Dtk_feat_geometry        **        object_to_mirror;
     Dtk_feat_geometry        *         reference; 
     long *                             input_ids;
 
     Dtk_tab<Dtk_FeaturePtr>            dtk_features;
     
     int                                     nb_elts;  
     int                                     nb_input_ids;
     
     bool                               gener_tool;
     bool                               isMirror;
     DTK_OBJECT_TYPE                         object_type; 
 
     Dtk_feat_mirror();
     ~Dtk_feat_mirror();
 
 
 
     //! \brief   Returns boolean value to denote whether it is a mirror or symmetric feature                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   1 : Mirror Feature , 0 : Symmetry feature 
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_isMirror  ( bool *);
 
 
 
     //! \brief   Returns object type                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]   DTK_OBJECT_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_object_type ( DTK_OBJECT_TYPE *);
 
 
     //! \brief   Returns the set of objects geometry to mirror.                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry ** (the geometry of the object to mirror)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_object_to_mirror ( Dtk_feat_geometry***); 
 
 
 
     //! \brief   Returns the number of elements to mirror.                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_elts ( int *); 
 
 
 
     //! \brief   Returns the geometry reference to mirror.                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat_geometry *                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_reference ( Dtk_feat_geometry**); 
 
 
 
     //! \brief   Returns the number of feature's IDs to mirror.                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_input_ids ( int *);
 
 
 
     //! \brief   Returns the array of Feature's IDs or Body ID to mirror.                                                
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   long *   (Array of IDs)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_input_ids ( long**);
 
 
 
     //! \brief   Returns the number of features resulted of the mirror feature. 
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_features ( int *);
 
 
 
     //! \brief   Returns the array of features resulted of the mirror feature. 
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_feat **                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> &);
 
 
 
 
     //! \brief   Returns the generated tool status to indicate whether features generated of the mirror have to be gotten or not.  
     //! \param [in]   Mirror Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   bool                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_gener_tool ( bool *);
 
 
} ;
 
/**
@brief Generic Symmetry Feature
*/ 
class Dtk_feat_symmetry {
 
public: 
 
     Dtk_feat_geometry*       reference; 
 
 
     //! \brief   Constructor of Symmetry Feature                                               
     //! \param [in]                                                  
     //! \param [in/out]                                                  
     //! \param [out]   Allocated Symmetry feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     Dtk_feat_symmetry(); 
 
 
 
     //! \brief     Destructor of a Symmetry Feature 
     //! \param [in]   Symmetry Feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Symmetry Feature  
     //! \remark           
 
 
     ~Dtk_feat_symmetry(); 
 
 
     //! \brief   Returns the reference geometry of the symmetry feature                                                
     //! \param [in]   Symmetry Feature                                               
     //! \param [in/out]                                                   
     //! \param [out]    Dtk_feat_geometry                                                                    
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_reference (Dtk_feat_geometry**);
 
};
 
 
 
/**
@brief Generic Translate Feature 
*/ 
 
class Dtk_feat_translate_direction 
{
public: 
     Dtk_feat_axis       * direction; 
     double                   distance; 
 
 
     //! \brief     Constructor of a direction translate Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated direction translate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_translate_direction ();
 
 
     //! \brief     Destructor a direction translate Feature  
     //! \param [in]   direction translate feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free direction translate Feature  
     //! \remark
 
     ~Dtk_feat_translate_direction (); 
 
 
     //! \brief   Returns the direction of the translate feature 
     //! \param [in]   Direction Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_direction ( Dtk_feat_axis **);
 
 
 
     //! \brief   Returns The distance of the translate feature
     //! \param [in]   Distance of the Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_distance ( double *);
 
 
};
 
 
 
class Dtk_feat_translate_point 
{
public: 
     Dtk_pnt                  start_point; 
     Dtk_pnt                  end_point;
 
 
 
     //! \brief     Constructor of a Point to Point translate Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated direction translate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_translate_point ();
 
 
 
     //! \brief     Destructor a point_to_point translate Feature  
     //! \param [in]   point_to_point translate feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free point_to_point translate Feature  
     //! \remark
 
     ~Dtk_feat_translate_point (); 
 
 
 
     //! \brief   Returns the start point of the translate feature 
     //! \param [in]   point_to_point Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_start_point ( Dtk_pnt *);
 
 
     //! \brief   Returns the end point of the translate feature 
     //! \param [in]   point_to_point Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_end_point ( Dtk_pnt *);
 
};
 
 
class Dtk_feat_translate_coordinates 
{
public: 
     double                   X; 
     double                   Y; 
     double                   Z; 
 
     Dtk_transfo *       AxisSystem;  
 
 
     //! \brief     Constructor of a coordinates translate Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated coordinates translate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_translate_coordinates();
 
 
 
     //! \brief     Destructor a coordinates translate Feature  
     //! \param [in]   coordinates translate feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free coordinates translate Feature  
     //! \remark
 
     ~Dtk_feat_translate_coordinates (); 
 
 
 
     //! \brief   Returns the first coordinate value of the translate feature 
     //! \param [in]   Coordinates Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_X ( double *);
 
 
 
     //! \brief   Returns the second coordinate value of the translate feature 
     //! \param [in]   Coordinates Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
     int  get_Y ( double *);
 
 
 
     //! \brief   Returns the Third coordinate value of the translate feature 
     //! \param [in]   Coordinates Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
 
     int  get_Z ( double *);
 
 
     //! \brief   Returns the Axis System of the coordinate translate feature 
     //! \param [in]   Axis System for the Translate Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
     int  get_axis_system  ( Dtk_transfo **);
 
};
 
 
class Dtk_feat_translate 
{
 
public: 
     TRANSLATE_TYPE                type; 
     bool                          isSurfaceTranslate; 
     Dtk_feat_surface_transfo*     surfaceTranslate; 
 
     union dtk_translate_type {
          Dtk_feat_translate_direction  *    trans_dir;
          Dtk_feat_translate_point      *    trans_pnt; 
          Dtk_feat_translate_coordinates     *    trans_coord; 
     }    entity;
 
 
     //! \brief     Constructor of a generic translate Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated generic translate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_translate();
 
 
 
     //! \brief     Destructor a generic translate Feature  
     //! \param [in]   generic translate feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free generic translate Feature  
     //! \remark
 
     ~Dtk_feat_translate (); 
 
 
 
     //! \brief   Returns the type of the translate feature 
     //! \param [in]   Generic Translate Feature                                              
     //! \param [in/out] TRANSLATE_TYPE
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_type ( TRANSLATE_TYPE *);
 
 
     //! \brief   Returns  Direction translate entity  
     //! \param [in]   Generic Translate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_translate_direction
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_direction_translate ( Dtk_feat_translate_direction **);
 
 
     //! \brief   Returns Point_to_point translate entity  
     //! \param [in]   Generic Translate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_translate_point
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_point_to_point_translate ( Dtk_feat_translate_point  **);
 
 
 
     //! \brief   Returns Coordinates translate entity  
     //! \param [in]   Generic Translate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_translate_direction
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_coordinates_translate ( Dtk_feat_translate_coordinates **);
 
 
     //! \brief   Returns the boolean value that indicates if the translate feature is a surface feature
     //! \param [in]   Generic Translate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   bool
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_is_surface_translate( bool*);
 
 
     //! \brief   Returns the surface translate entity, the translate should be surface to be able to call this function  
     //! \param [in]   Generic Translate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_surface_transfo
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_surface_translate( Dtk_feat_surface_transfo**);
};
 
 
/**
@brief Generic Rotate Feature 
*/ 
 
class Dtk_feat_rotate_axis 
{
public: 
     Dtk_feat_axis       * axis; 
     double                   angle; 
 
 
     //! \brief     Constructor of a rotation with axis Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated rotation with axis feature  
     //! \return    
     //! \remark
 
     Dtk_feat_rotate_axis ();
 
 
     //! \brief     Destructor a rotation with axis Feature  
     //! \param [in]  rotation with axis feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free rotation with axis  Feature  
     //! \remark
 
     ~Dtk_feat_rotate_axis (); 
 
 
     //! \brief   Returns the axis of the rotation feature 
     //! \param [in]   Rotation with Axis Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_axis ( Dtk_feat_axis **);
 
 
 
     //! \brief   Returns The angle of the rotation feature
     //! \param [in]   Angle of the rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_angle ( double *);
 
 
};
 
 
 
class Dtk_feat_rotate_points 
{
public: 
     Dtk_pnt                  first_point; 
     Dtk_pnt                  second_point;
     Dtk_pnt                  third_point;
 
 
 
     //! \brief     Constructor of a "Three Points" rotation Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated "Three Points" rotation feature  
     //! \return    
     //! \remark
 
     Dtk_feat_rotate_points ();
 
 
 
     //! \brief     Destructor a a "Three Points" rotation Feature  
     //! \param [in]   pa "Three Points" rotation feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free a "Three Points" rotation Feature  
     //! \remark
 
     ~Dtk_feat_rotate_points (); 
 
 
 
     //! \brief   Returns the first point of the rotation feature 
     //! \param [in]   "Three Points" rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_first_point ( Dtk_pnt *);
 
 
 
     //! \brief   Returns the second point of the rotation feature 
     //! \param [in]   "Three Points" rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_second_point ( Dtk_pnt *);
 
 
     //! \brief   Returns the third point of the rotation feature 
     //! \param [in]   "Three Points" rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_third_point ( Dtk_pnt *);
 
};
 
 
class Dtk_feat_rotate_axis_elements 
{
public: 
 
     Dtk_feat_axis  *         axis; 
     Dtk_feat_geometry *      first_element; 
     Dtk_feat_geometry *      second_element; 
 
 
 
     //! \brief     Constructor of a "Axis-Element" Rotation Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated coordinates rotate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_rotate_axis_elements();
 
 
 
     //! \brief     Destructor a "Axis-Element" Rotation Feature  
     //! \param [in]   "Axis-Element" Rotation feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Axis-Element" Rotation Feature  
     //! \remark
 
     ~Dtk_feat_rotate_axis_elements (); 
 
 
 
     //! \brief   Returns the axis value of the rotate feature 
     //! \param [in]   Axis of the rotate  Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_axis ( Dtk_feat_axis **);
 
 
 
     //! \brief   Returns the first element of the rotate feature 
     //! \param [in]  "Axis-Element" Rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
     int  get_first_element ( Dtk_feat_geometry **);
 
 
 
     //! \brief   Returns the second element of the rotate feature 
     //! \param [in]  "Axis-Element" Rotation Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
 
     int  get_second_element ( Dtk_feat_geometry **);
 
 
};
 
 
class Dtk_feat_rotate 
{
 
public: 
     ROTATE_TYPE                        type; 
     bool                          isSurfaceRotate; 
     Dtk_feat_surface_transfo*     surfaceRotate; 
 
     union dtk_rotate_type {
          Dtk_feat_rotate_axis *                  rotate_axis;
          Dtk_feat_rotate_points *           rotate_pnts;
          Dtk_feat_rotate_axis_elements*          rotate_axis_elements; 
     }    entity;
 
 
     //! \brief     Constructor of a generic rotate Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated generic rotate feature  
     //! \return    
     //! \remark
 
     Dtk_feat_rotate();
 
 
 
     //! \brief     Destructor a generic rotate Feature  
     //! \param [in]   generic rotate feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free generic rotate Feature  
     //! \remark
 
     ~Dtk_feat_rotate (); 
 
 
 
     //! \brief   Returns the type of the rotate feature 
     //! \param [in]   Generic Rotate Feature                                              
     //! \param [in/out] ROTATE_TYPE                                      
     //! \param [out]   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_type ( ROTATE_TYPE *);
 
 
     //! \brief   Returns  Axis rotate entity  
     //! \param [in]   Generic rotate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_rotate_axis
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_axis_angle_rotate ( Dtk_feat_rotate_axis **);
 
 
     //! \brief   Returns "Three Points " rotate entity  
     //! \param [in]   Generic Rotate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_rotate_points
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_three_points_rotate ( Dtk_feat_rotate_points **);
 
 
 
     //! \brief   Returns "Axis - Two Elements " rotate entity  
     //! \param [in]   Generic Rotate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_rotate_axis_elements
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_axis_twoElements_rotate ( Dtk_feat_rotate_axis_elements **);
 
 
     //! \brief   Returns the boolean value that indicates if the rotate feature is a surface feature
     //! \param [in]   Generic Rotate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   bool
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_is_surface_rotate ( bool*);
 
 
     //! \brief   Returns the surface rotate entity, the rotate should be surface to be able to call this function  
     //! \param [in]   Generic Rotate Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_surface_transfo
 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_surface_rotate( Dtk_feat_surface_transfo**);
 
};
 
 
class Dtk_feat_boolean {
public:
 
     Dtk_feat*                     main_body;          // The body second operand from (subtract)|to (add)|with (intersect) which the operation boolean is applied   
     Dtk_FeaturePtr                combined_body; // The body feature on which the boolean operation is applied    
     long                          nb_combined_bodies; // The number of the combined bodies as default it equals 1
     DTK_BOOLEAN_TYPE              type;
     Dtk_feat_boolean (); 
     ~Dtk_feat_boolean(); 
 
 
 
     //! \brief   Returns boolean operation type                                                 
     //! \param [in]   Boolean Operation                                                
     //! \param [in/out]                                                   
     //! \param [out]   DTK_BOOLEAN_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_type        ( DTK_BOOLEAN_TYPE *);
 
 
 
     //! \brief   Returns body feature operand consisting the combined body operand of the boolean operation                                                 
     //! \param [in]   Boolean Operation                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat *
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_combined_body         ( Dtk_FeaturePtr &);
 
 
 
     //! \brief   Returns body feature consisting the main body operand of the boolean operation                                                 
     //! \param [in]   Boolean Operation                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat *
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_main_body        ( Dtk_FeaturePtr &);
 
 
 
     //! \brief   Returns number of the bodies involved in the combined feature body of the boolean operation                                                 
     //! \param [in]   Boolean Operation                                                
     //! \param [in/out]                                                   
     //! \param [out]   long *
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_nb_combined_bodies         ( long*);
 
};
 
 
 
/**
@brief Draft Neutral Element 
*/
class Dtk_feat_draft_neutral_element {
 
public:
 
     Dtk_feat_geometry        ** profiles; 
     
     int                           profiles_nb; 
     PROPAGATION_TYPE         propagation; 
 
     Dtk_feat_draft_neutral_element();
     ~Dtk_feat_draft_neutral_element ();
 
 
 
 
     //! \brief   Returns Neutral Propagation                                                
     //! \param [in]   Draft Neutral Element                                                
     //! \param [in/out]                                                   
     //! \param [out]   PROPAGATION_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_propagation      ( PROPAGATION_TYPE *);
 
 
 
 
 
     //! \brief   Returns number of profiles of the neutral element 
     //! \param [in]   Draft Neutral Element                                                
     //! \param [in/out]                                                   
     //! \param [out]   int          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_profiles_nb      ( int*);
 
 
     //! \brief   Returns Neutral Element geometric List                                               
     //! \param [in]   Draft Neutral Element                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry *              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_profiles         ( Dtk_feat_geometry***);
 
 
};
 
 
/**
@brief Draft Side
*/
class Dtk_feat_draft_side {
 
public:
 
     Dtk_feat_axis                      * direction;  
     double                                    angle; 
     Dtk_feat_draft_neutral_element     * neutral_element; 
 
     Dtk_feat_draft_side();
     ~Dtk_feat_draft_side ();
 
 
 
     //! \brief     Returns the draft direction according to the specified draft side.                                                 
     //! \param [in]   Draft Side                                              
     //! \param [in/out]                                                  
     //! \param [out]   DTK Axis                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_direction       (Dtk_feat_axis **);
 
 
 
     //! \brief   Returns Draft Side Angle                                               
     //! \param [in]   Draft Side                                                
     //! \param [in/out]                                                   
     //! \param [out]   double            
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_angle       ( double *);
 
 
 
     //! \brief   Returns the draft neutral element  
     //! \param [in]   Draft Side                                                
     //! \param [in/out]                                                   
     //! \param [out]   Neutral Element             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_neutral_element       ( Dtk_feat_draft_neutral_element **);
 
};
 
 
/**
@brief Draft point
*/
class Dtk_feat_draft_var_point {
 
public:
 
 
     Dtk_pnt                       point;
     double                        angle;
     double                        ratio;
 
     DTK_POINT_CONSTRUCTION        point_construction; /* debug info */
     long                     construct_geom;
 
     Dtk_feat_geometry   *    elt; /* elt = parent edge if on_edge = DTK_TRUE
                                         geometric ID if on_edge = DTK_FALSE */
 
     Dtk_feat_draft_var_point();
     ~Dtk_feat_draft_var_point ();
 
 
 
     //! \brief   Returns Draft point                                          
     //! \param [in]   Draft point                                              
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_pnt
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_point ( Dtk_pnt*);
 
     //! \brief   Returns fillet point angle                                         
     //! \param [in]   Draft point angle                                              
     //! \param [in/out]                                                   
     //! \param [out]   double 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_angle ( double *);
 
     //! \brief   Returns draft point ratio on attached edge                                       
     //! \param [in]   Draft point                                              
     //! \param [in/out]                                                   
     //! \param [out]   double 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_ratio ( double *);
 
 
 
     //! \brief   Returns Draft point element                                         
     //! \param [in]   Draft point                                              
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_elt ( Dtk_feat_geometry **);
 
 
 
} ;
 
/**
@brief Draft Parting Element 
*/
class Dtk_feat_parting_element {
 
public:
 
     Dtk_feat_geometry   * profile; 
     Bool                both_sides; 
     Bool                isEqualNeutral; 
 
     Dtk_feat_parting_element();
     ~Dtk_feat_parting_element ();
 
 
 
     //! \brief   Returns Parting element geometry                                        
     //! \param [in]   Draft Parting Element                                               
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_profile ( Dtk_feat_geometry **);
 
 
     //! \brief   Returns a bool variable indicating whether the parting element is equal the neutral element or not                                            
     //! \param [in]   Draft Parting Element                                           
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_isEqualNeutral ( Bool *);
 
 
     //! \brief   Returns a boolean value whether parting element is applied over both or one side                                             
     //! \param [in]   Draft Parting Element                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_both_sides ( Bool *);
 
} ;
 
 
 
/**
@brief Generic Feature Standard Constant Draft
*/
class Dtk_feat_draft_constant {
 
public:
 
 
     SELECTION_MODE      selection;
     DRAFT_FORM               form; 
 
     Dtk_feat_draft_neutral_element      * neutral_element;
 
 
 
     //! \brief     Constructor of standard constant Draft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated constant draft feature   
     //! \return    
     //! \remark
 
     Dtk_feat_draft_constant(); 
 
 
     //! \brief     Destructor of a draft feature 
     //! \param [in]   draft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free draft Feature  
     //! \remark
 
     ~Dtk_feat_draft_constant();
 
 
 
     //! \brief   Returns Constant Draft Form  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   DRAFT_FORM
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_form ( DRAFT_FORM *);  
 
 
 
     //! \brief   Returns Constant Draft selection mode                                           
     //! \param [in]   Constant Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   SELECTION_MODE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_selection ( SELECTION_MODE *);
 
 
 
     //! \brief   Returns the neutral element                                           
     //! \param [in]   Constant Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_neutral_element
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
};
 
/**
@brief Generic Feature Standard Variable Draft
*/
class Dtk_feat_draft_variable {
 
public:
 
 
     Dtk_feat_draft_neutral_element * neutral_element;
 
     Dtk_feat_draft_var_point ** var_points; 
     int                      var_points_nb; 
 
 
 
 
     //! \brief     Constructor of Variable Draft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated variable draft feature  
     //! \return    
     //! \remark
 
     Dtk_feat_draft_variable ();
 
 
     //! \brief     Destructor of a variable draft feature 
     //! \param [in]   variable draft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free variable draft Feature  
     //! \remark
 
     ~Dtk_feat_draft_variable (); 
 
 
 
     //! \brief   Returns the neutral elements 
     //! \param [in]   Variable Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_neutral_element
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
 
 
 
     //! \brief   Returns array of draft points of a variable Draft  
     //! \param [in]   Variable Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_var_point
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_var_points ( Dtk_feat_draft_var_point ***);  
 
 
 
     //! \brief   Returns number of draft points in a variable Draft  
     //! \param [in]   Variable Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   int
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_var_points_nb ( int *);  
 
 
 
};
 
 
 
/**
@brief Feature Reflect Line Draft
*/
class Dtk_feat_draft_reflect_line {
 
public:
 
 
 
     //! \brief     Constructor of reflect line Draft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated reflect line draft feature   
     //! \return    
     //! \remark
 
     Dtk_feat_draft_reflect_line(); 
 
 
     //! \brief     Destructor of a reflect line draft feature 
     //! \param [in]   advanced draft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free reflect line draft Feature  
     //! \remark
 
     ~Dtk_feat_draft_reflect_line();
};
 
 
/**
@brief Feature Advanced Draft
*/
class Dtk_feat_draft_advanced {
 
public:
 
 
     SELECTION_MODE                     selection;
     DRIVING_MODE                       driving_mode;
     DRIVING_SIDE                       driving_side; 
 
     double                                  fitted_parameter;
 
     Dtk_feat_draft_neutral_element     * neutral_element;
     Dtk_feat_draft_side                * second_side;
 
 
 
 
 
     //! \brief     Constructor of advanced Draft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated advanced draft feature   
     //! \return    
     //! \remark
 
     Dtk_feat_draft_advanced(); 
 
 
     //! \brief     Destructor of an advanced draft feature 
     //! \param [in]   advanced draft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free advanced draft Feature  
     //! \remark
 
     ~Dtk_feat_draft_advanced();
 
 
 
 
     //! \brief   Returns advanced Draft selection mode                                           
     //! \param [in]   Advanced Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   SELECTION_MODE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_selection ( SELECTION_MODE *);
 
 
 
     //! \brief   Returns advanced Draft Driving Mode                                            
     //! \param [in]   Advanced Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]  DRIVING_MODE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_driving_mode ( DRIVING_MODE *);
 
 
 
     //! \brief   Returns the driving side 
     //! \param [in]   Advanced Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]  DRIVING_SIDE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark    
 
     int  get_driving_side  ( DRIVING_SIDE *);
 
 
     //! \brief   Returns Draft fitted parameter value                                           
     //! \param [in]   Advanced Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   double
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_fitted_parameter ( double *);
 
 
 
     //! \brief   Returns the advanced draft second side (one or two sides may be presented in an advanced draft)                                            
     //! \param [in]   Advanced Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_side
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_second_side ( Dtk_feat_draft_side **);
 
 
     //! \brief   Returns array of draft's sides (one or two sides)                                            
     //! \param [in]   Advanced Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_neutral_element
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
};
 
 
 
/**
@brief Generic Feature Draft
*/
class Dtk_feat_draft {
 
public:
     
     union  Dtk_feat_draft_type { 
          Dtk_feat_draft_constant            *    cte_angle;
          Dtk_feat_draft_variable            *    var_angle;
          Dtk_feat_draft_reflect_line        *    reflect_line;
          Dtk_feat_draft_advanced            *    advanced_draft;
 
     } entity;
 
     Dtk_feat_parting_element * parting_elt; 
     Dtk_feat_geometry   **limiting_elements;
     Dtk_feat_axis       * default_direction; 
     Dtk_feat_geometry   **   draft_faces;
 
     double                   default_angle; 
     int                      limiting_elements_nb; 
     int                      draft_faces_nb; 
     DRAFT_TYPE               type;
 
 
 
 
     //! \brief     Constructor of Draft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated draft feature  
     //! \return    
     //! \remark
 
     Dtk_feat_draft ();
 
 
     //! \brief     Destructor of a draft feature 
     //! \param [in]   draft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free draft Feature  
     //! \remark
 
     ~Dtk_feat_draft (); 
 
 
 
 
     //! \brief   Returns Draft Type                                          
     //! \param [in]   Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   DRAFT_TYPE
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_type ( DRAFT_TYPE *);
 
 
 
     //! \brief   Returns Draft default angle value applied in case of one side draft                                           
     //! \param [in]   Draft Feature                                              
     //! \param [in/out]                                                   
     //! \param [out]   double
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int  get_default_angle ( double *);
 
 
     //! \brief     Returns the default draft direction.                                                 
     //! \param [in]   Draft Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   DTK Axis                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_default_direction    (Dtk_feat_axis **);
 
 
 
     //! \brief   Returns Parting element 
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_parting_element
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_parting_element ( Dtk_feat_parting_element **);
 
 
 
     //! \brief   Returns geometries of Draft faces in case of multi faces selection mode 
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_draft_faces ( Dtk_feat_geometry ** *); 
 
 
     //! \brief   Returns number of Draft faces in case of multi faces selection mode 
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   int
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_draft_faces_nb ( int *);  
 
 
 
     //! \brief   Returns profiles of limiting elements list 
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_limiting_elements ( Dtk_feat_geometry ***);  
 
 
 
     //! \brief   Returns number of limiting elements list  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   int
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_limiting_elements_nb ( int *);  
 
 
 
     //! \brief   Returns constant draft entity  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_constant
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_constant_draft ( Dtk_feat_draft_constant **);
 
 
     //! \brief   Returns variable draft entity  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_variable
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_variable_draft ( Dtk_feat_draft_variable **); 
 
 
     //! \brief   Returns reflect line draft entity  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_reflect_line                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_reflect_line_draft ( Dtk_feat_draft_reflect_line **);
 
 
     //! \brief   Returns advanced draft entity  
     //! \param [in]   Draft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_draft_advanced
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_advanced_draft ( Dtk_feat_draft_advanced **); 
 
 
};
 
 
 
/**
@brief Generic Feature Stiffener
*/
class Dtk_feat_stiffener {
 
public:
 
     Dtk_feat_geometry * profile; 
           
     double                   thick1; 
     double                   thick2; 
     Bool                isNeutralFiber; 
     Bool                isReverseThickness; 
     Bool                isReverseDepth; 
     STIFFENER_MODE      mode;
 
 
 
     //! \brief     Constructor of Stiffener Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated stiffener feature  
     //! \return    
     //! \remark
 
     Dtk_feat_stiffener ();
 
 
     //! \brief     Destructor of a Stiffener feature 
     //! \param [in]   Stiffener feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free stiffener Feature  
     //! \remark
 
     ~Dtk_feat_stiffener (); 
 
 
 
 
     //! \brief     Gets the profile of the stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    Dtk_feat_geometry                                                      
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_profile (Dtk_feat_geometry **);
 
 
 
 
     //! \brief     Gets the mode of the stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    STIFFENER_MODE                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_mode (STIFFENER_MODE *); 
 
 
 
     //! \brief     Gets the first thickness of the stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    double                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_thick1 (double *); 
 
 
 
     //! \brief     Gets the second thickness of the stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    double                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_thick2 (double *); 
 
 
 
     //! \brief     Gets the neutral fiber boolean option of the stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    Bool                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_isNeutralFiber (Bool *); 
 
 
 
     //! \brief     Gets the Thickness reverse direction boolean of the  stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    Bool                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_isReverseThickness (Bool *); 
 
 
 
     //! \brief     Gets the Depth reverse direction boolean of the  stiffener feature                                                       
     //! \param [in]     Stiffener feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    Bool                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_isReverseDepth(Bool *); 
 
}; 
 
 
 
 
/**
@brief Generic Feature Scaling
*/
class Dtk_feat_scaling {
 
public:
 
     Dtk_feat_geometry * reference; 
     double                   ratio;  
 
 
 
 
     //! \brief     Constructor of Scaling Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated Scaling feature  
     //! \return    
     //! \remark
 
     Dtk_feat_scaling ();
 
 
     //! \brief     Destructor of a Scaling feature 
     //! \param [in]   Scaling feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Scaling Feature  
     //! \remark
 
     ~Dtk_feat_scaling (); 
 
 
 
 
     //! \brief     Gets the geometric reference of the scaling feature                                                       
     //! \param [in]     Scaling feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    Dtk_feat_geometry                                                      
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_reference (Dtk_feat_geometry **);
 
 
 
     //! \brief     Gets the ratio of the scaling feature                                                       
     //! \param [in]     Scaling feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    double                                                      
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_ratio (double *);
 
 
}; 
 
 
/**
@brief Loft Section 
*/
class Dtk_feat_loft_section {
 
public:
 
 
 
     Dtk_feat_geometry*       sectionCurve; 
     Dtk_feat_geometry*       closingPoint; 
 
     /* tangent ???  */
 
 
     Dtk_feat_loft_section();
     ~Dtk_feat_loft_section ();
 
 
     //! \brief   Returns loft section curve 
     //! \param [in]   Loft section entity                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry *              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_section_curve (Dtk_feat_geometry**);
 
 
     //! \brief   Returns section closing point 
     //! \param [in]   Loft section entity                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry *              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_closing_point (Dtk_feat_geometry**);
 
 
};
 
/**
@brief Loft Guide 
*/
class Dtk_feat_loft_guide {
 
public:
 
 
 
     Dtk_feat_geometry*       guideCurve; 
     int                           guideDimension; 
 
 
     Dtk_feat_loft_guide();
     ~Dtk_feat_loft_guide ();
 
 
     //! \brief   Returns loft guide curve
     //! \param [in]   Loft guide entity                                                
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_geometry *              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_guide_curve (Dtk_feat_geometry**);
 
 
     //! \brief   Returns loft guide dimension // 2 or 3
     //! \param [in]   Loft guide entity                                                
     //! \param [in/out]                                                   
     //! \param [out]   int          
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_guide_dimension (int*);
 
};
 
 
 
 
/**
@brief Loft Coupling  
*/
class Dtk_feat_loft_coupling {
 
public:   
          
     Dtk_tab<Dtk_feat_geometry*>        couplingPoints;
     //   int                                     couplingPointsNb;
     Bool                               couplingDisplay;
     COUPLING_TYPE                      couplingType;  
 
     Dtk_feat_loft_coupling();
     ~Dtk_feat_loft_coupling();
 
 
 
     //! \brief   Returns Coupling type                                               
     //! \param [in]   Loft Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   COUPLING_TYPE                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_type (COUPLING_TYPE *);
 
 
 
     //! \brief   Returns array of loft coupling points  
     //! \param [in]   Loft Coupling element 
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_tab <Dtk_feat_geometry*>                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_coupling_points (Dtk_tab<Dtk_feat_geometry*> &); 
 
 
     //! \brief   Returns number of loft coupling points  
     //! \param [in]   Loft Coupling element                                        
     //! \param [in/out]                                                   
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_coupling_points_nb ( int *); 
 
 
     //! \brief   Returns loft coupling display boolean value 
     //! \param [in]   Loft coupling element entity                                                
     //! \param [in/out]                                                   
     //! \param [out]   Bool 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_coupling_display  (Bool *);
 
};
 
 
 
/**
@brief Generic Feature Loft
*/
 
class Dtk_feat_loft {
 
public:
 
     Dtk_tab <Dtk_feat_loft_section*>   loftSections; 
     //   int                                          loftSectionNb; 
 
     Dtk_tab<Dtk_feat_loft_guide*>      loftGuides; 
     //   int                                          loftGuidesNb; 
 
     Dtk_feat_loft_coupling*                 loftCoupling; 
     Dtk_feat_geometry*                      spine;
     double                                       angularCorrection;
     double                                       deviation;
 
     Bool                                    isComputedSpine;
     Bool                                    relimited_start_section;
     Bool                                    relimited_end_section;
     DTK_LOFT_TYPE                           loftType; 
 
 
     //! \brief     Constructor of Loft Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated loft feature  
     //! \return    
     //! \remark
 
     Dtk_feat_loft();
 
 
     //! \brief     Destructor of a Loft feature 
     //! \param [in]   Loft feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Loft Feature  
     //! \remark
 
     ~Dtk_feat_loft();
 
 
 
 
     //! \brief   Returns Loft type                                               
     //! \param [in]   Loft Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   DTK_LOFT_TYPE                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_type                  (DTK_LOFT_TYPE *);
 
 
 
     //! \brief   Returns array of loft sections 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_tab <Dtk_feat_loft_section*>                                                 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_sections (Dtk_tab <Dtk_feat_loft_section*> &); 
 
 
 
     //! \brief   Returns number of Loft sections 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_sections_nb ( int *);  
 
 
     //! \brief   Returns array of loft guides 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_tab <Dtk_feat_loft_guide*>                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_guides (Dtk_tab <Dtk_feat_loft_guide*> &); 
 
 
 
     //! \brief   Returns number of Loft guides 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   int                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_guides_nb ( int *);  
 
 
 
     //! \brief   Returns loft coupling entity  
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_loft_coupling*                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_coupling ( Dtk_feat_loft_coupling **); 
 
 
 
     //! \brief   Returns loft spine geometry   
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Dtk_feat_loft_coupling*                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_spine ( Dtk_feat_geometry **); 
 
 
 
     //! \brief   Returns boolean value whether the spine is automatically computed    
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Bool                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_isComputedSpine ( Bool *); 
 
 
     //! \brief   Returns boolean value whether the loft is restricted from the start 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Bool                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_relimited_start_section ( Bool *); 
 
 
     //! \brief   Returns boolean value whether the loft is restricted from the start 
     //! \param [in]   Loft Feature                                            
     //! \param [in/out]                                                   
     //! \param [out]   Bool                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int  get_relimited_end_section ( Bool *);
 
};
 
 
/*
@brief Generic Feature Loft
 
 
 
class Dtk_feat_loft {
 
public:
 
 
Dtk_tab<Dtk_feat_geometry*>   SectionCurve;
int                                nb_sectionCurve;
 
Dtk_tab<Dtk_feat_geometry*>   SectionPoint;
int                                nb_sectionPoint;
 
Dtk_tab<Dtk_feat_geometry*>   guide;
int                                nb_guides;
Dtk_tab<Dtk_feat_geometry*> pnt1;
Dtk_tab<Dtk_feat_geometry*> pnt2;
 
 
COUPLING_TYPE                 type;
Dtk_tab<Dtk_feat_geometry*> coupling;
Dtk_tab<Dtk_feat_geometry*> pnt_coupling;
 
int                                nb_coupling;
int                                nb_pnt_coupling;
Bool                          Display_coupling;
 
Dtk_feat_geometry        *    spine;
int                                nb_spine;
Bool                          computed_spine;
 
Bool                          relimited_start_section;
Bool                          relimited_end_section;
 
double                             val_angular_correction;
double                             val_deviation;
 
 
int                                OperationType;
Bool                          isPositiveLoft;
Bool                          isNegativeLoft;
 
Dtk_tab<int>                  GuidedCurve2D;
 
Dtk_feat_loft();
~Dtk_feat_loft();   
};
*/
 
 
 
class Dtk_feat_thickness_feat {
 
public:
     double                                       defaultThickness; 
     Dtk_tab <Dtk_feat_geometry*>       defaultFaces; 
     //   int                                          defaultFacesNb; 
 
     Dtk_tab <Dtk_feat_thickness_face*> otherSkins;
     //   int                                          otherSkinsNb; 
 
     /*
     double                             val_epaisseur;
     Dtk_tab<double>                    val_autre_epaisseur;
 
     Dtk_tab<Dtk_feat_geometry     *> face_epaisseur;
     int                                nb_faces;
 
     Dtk_tab<Dtk_feat_geometry     *> face_autre_epaisseur;
     int                                nb_faces_autres;*/
 
 
 
     //! \brief     Constructor of Thickness Feature   
     //! \param [in]     
     //! \param [in/out]
     //! \param [out]    Allocated Thickness feature  
     //! \return    
     //! \remark
 
     Dtk_feat_thickness_feat ();
 
 
     //! \brief     Destructor of a Thickness feature 
     //! \param [in]   Thickness feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Thickness Feature  
     //! \remark
 
     ~Dtk_feat_thickness_feat ();
 
 
 
     //! \brief     Get the default thickness value of the feature Thickness 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   double 
     //! \return    Default Thickness value of Thickness Feature  
     //! \remark
 
     int get_default_thickness (double *);
 
 
     //! \brief     Get the number of thickened faces of the feature Thickness 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   int 
     //! \return    Number of thickened faces number of Thickness Feature  
     //! \remark
 
     int get_nb_default_faces ( int *);
 
 
 
     //! \brief   Returns the array of default faces geometry of the feature Thickness                                                
     //! \param [in]   Thickness feature                                                
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_tab<Dtk_feat_geometry*> (Array of faces geometry)                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_default_faces ( Dtk_tab<Dtk_feat_geometry*> &); 
 
 
 
     //! \brief     Get the number of other skins (thickness for each skin) of the feature Thickness 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   int 
     //! \return    Number of skins of Thickness Feature  
     //! \remark
 
     int get_nb_skins ( int *);
 
 
 
     //! \brief     Get the array of skins (thickness for each skin) of the feature Thickness 
     //! \param [in]   Thickness feature   
     //! \param [in/out]     
     //! \param [out]   Dtk_tab <Dtk_feat_thickness_face*>
     //! \return    skins array of Thickness Feature  
     //! \remark
 
     int get_skins ( Dtk_tab <Dtk_feat_thickness_face*> & );
 
 
};
 
 
 
/**
@brief Multi prism domain 
*/
class Dtk_feat_prism_domain {
 
public:   
 
     Dtk_feat_geometry * profile; 
     Dtk_feat_limit*          first_limit;   
     Dtk_feat_limit*          second_limit;
 
     Dtk_feat_prism_domain();
     ~Dtk_feat_prism_domain();
 
 
 
     //! \brief     Returns the first limit of the prism domain feature.  
     //! \param [in]   Multi Prism domain Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    First Limit Feature                                  
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_first_limit               (Dtk_feat_limit **);
 
 
     //! \brief     Returns the second limit of the prism domain feature.                                         
     //! \param [in]   Multi Prism domain Feature                                            
     //! \param [in/out]                                                  
     //! \param [out]   Second Limit Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_second_limit              (Dtk_feat_limit **);
 
 
 
 
     //! \brief   Returns the profile internal component of the multi prism domain feature.                                                
     //! \param [in]   Multi Prism domain Feature                                           
     //! \param [in/out]                                                  
     //! \param [out]   Profile geometry                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_profile    (Dtk_feat_geometry **);
 
};
 
/**
@brief    Multi Prism Feature : A repetition of Prism extrudes a profile along a specific direction. 
A Pad adds material, a Pocket removes material. 
*/
class Dtk_feat_multi_prism {
 
public:
                              
     Dtk_feat_geometry   *              profiles;
     Dtk_feat_axis       *              direction;     
     Dtk_tab<Dtk_feat_prism_domain*>    prism_domains;
     Bool                               normal_to_surface;
     DTK_PRISM_TYPE                     type;
     //   int                                     domainsNb; 
 
public :
 
 
     //! \brief   Constructor of Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Allocated Multi prism feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     Dtk_feat_multi_prism ();
 
     //! \brief     Destructor of a Multi prism feature 
     //! \param [in]   Multi Prism feature to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Multi Prism Feature  
     //! \remark           
 
 
     ~Dtk_feat_multi_prism ();
 
     //! \brief   Returns Multi Prism type                                               
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]  DTK_PRISM_TYPE                       
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int get_type                  (DTK_PRISM_TYPE *);
 
 
     //! \brief   Returns the multi prism profiles internal component.                                                
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Profile geometry                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
 
     //! \brief     Returns the multi prism (extrusion or pocket) direction.                                                 
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   DTK Axis                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_direction  (Dtk_feat_axis **);
 
 
     //! \brief     Returns the normal to surface.                                                 
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Bool                                             
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_normal_to_surface    (Bool*);
 
 
 
     //! \brief     Returns the array of multi prism domains                                          
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Dtk_tab <Dtk_feat_prism_domain*>                                        
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_prism_domains   (Dtk_tab <Dtk_feat_prism_domain*> &);
 
 
     //! \brief     Returns the number of multi prism domains                                             
     //! \param [in]   Multi Prism Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   int                                         
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark                                                  
 
 
     int  get_domains_nb (int*);
 
 
};
 
 
/* Body feature */
class Dtk_feat_body {
 
public:
 
     DTK_BODY_TYPE  type; 
     Bool           isVisible;     
     //long              inner_feat_nb;
     Dtk_tab<Dtk_FeaturePtr> dtk_inner_feat_tab;
     //Dtk_feat **       inner_feat_tab;          
 
 
 
 
     //! \brief     Constructor of a body feature                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated body feature                          
     //! \remark                                                     
 
 
     Dtk_feat_body();
 
 
 
 
     //! \brief     Destructor of a body feature                                               
     //! \param [in] feature body to destruct                                                  
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free body                          
     //! \remark                                                         
 
     ~Dtk_feat_body();
 
 
 
 
     //! \brief     Gets the number of direct inner features                                                       
     //! \param [in]     Body feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    int                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_inner_feat_nb (long *);
 
 
 
 
     //! \brief     Get the body array containing pointers to direct inner features                                                    
     //! \param [in]     Body                                                   
     //! \param [in/out]                                                      
     //! \param [out]    Dtk_feat **                                                 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_inner_feat_tab (Dtk_tab<Dtk_FeaturePtr> &);
 
 
 
 
     //! \brief     Get the body Visibility                                                     
     //! \param [in]     Body                                                   
     //! \param [in/out]                                                      
     //! \param [out]    Bool *                                                 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_visibility  (Bool *);
 
 
 
 
 
     //! \brief     Get the body type (Solid or Surface)                                                     
     //! \param [in]     Body                                                   
     //! \param [in/out]                                                      
     //! \param [out]    DTK_BODY_TYPE *                                                 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_type  (DTK_BODY_TYPE *);
 
};
 
typedef enum    
{
     DTK_USER_DEFINED_DOUBLE = 0,
     DTK_USER_DEFINED_INT,
     DTK_USER_DEFINED_STRING,
     DTK_USER_DEFINED_IDGEOM,
     DTK_USER_DEFINED_LENGTH,
     DTK_USER_DEFINED_ANGLE,
     DTK_USER_DEFINED_NOVALUE
 
} DTK_USER_DEFINED_VAL_TYPE;
 
class Dtk_feat_user_defined_value
{
public:
          
     Dtk_NodeConnectorPtr geomConnector; 
     Dtk_string stringValue;
     Dtk_string role;
     double doubleValue;
     int integerValue;
     DTK_USER_DEFINED_VAL_TYPE type;
          
     Dtk_feat_user_defined_value ()
     {
          this->type = DTK_USER_DEFINED_NOVALUE;
          this->integerValue = -1;
          this->doubleValue = 0.0;
          this->geomConnector = NULL; 
     }
     ~Dtk_feat_user_defined_value ();
     Dtk_feat_user_defined_value (const Dtk_feat_user_defined_value & inValue)
     {
          this->role = inValue.role;
          this->type = inValue.type;
          this->integerValue = inValue.integerValue;
          this->doubleValue = inValue.doubleValue;
          this->stringValue = inValue.stringValue;
          this->geomConnector = inValue.geomConnector;      
     }
 
     //! \brief     Get the User Defined Value type (Double, Length, Angle, Int, GeomID, NoValue, etc.)                                                      
     //! \param [out]    User Defined Type  as DTK_USER_DEFINED_VAL_TYPE 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_type (DTK_USER_DEFINED_VAL_TYPE & outType); 
 
     //! \brief     Get the User Defined Value role, defined as the title of the value 
     //! \param [out]    User Defined role as Dtk_string
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_role (Dtk_string & outRole); 
 
     //! \brief     Get the User Defined Value 
     //! \param [out]    User Defined Value as double (for Double, Angle, Length)
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_double (double & outValue); 
 
     //! \brief     Get the User Defined Value 
     //! \param [out]    User Defined Value as Integer (for Integer and GeomID)
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_integer (int & outValue); 
 
     //! \brief     Get the User Defined Value 
     //! \param [out]    User Defined Type  as String
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_string (Dtk_string & outValue); 
 
     //! \brief     Get the User Defined Value - Node Connector to retrieve geometric entities using _ReadConnectedEntity. 
     //! \brief     This method is available only for Dtk_Component/Dtk_Node based approach
     //! \param [out]    User Defined Type  as ID GEOM
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
     int get_value_node_connector (Dtk_NodeConnectorPtr & outValue); 
 
};
 
class Dtk_feat_user_defined
{
 
public:
 
     Dtk_string                                   type;
     Dtk_string                                   name;
 
     Dtk_tab<Dtk_feat_user_defined_value> vals;
 
 
     Dtk_feat_user_defined ();
     ~Dtk_feat_user_defined ();
 
     //! \brief     Get the User Defined Feature type                                                      
     //! \param [out]    User Defined Type defined with Dtk_string 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_type  (Dtk_string & outType);
 
 
     //! \brief     Get the User Defined Feature Name                                                      
     //! \param [out]    User Defined Name as Dtk_string 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_name  (Dtk_string & outName);
 
 
     //! \brief     Get the User Defined Feature Value by its position                                                    
     //! \param [out]    User Defined Feature as object of Dtk_feat_user_defined_value  
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_user_defined_value_by_pos (int pos, Dtk_feat_user_defined_value & outUserDefinedValue);
};
 
 
class Dtk_feat_surf_feature
{
public: 
     DTK_SURF_FEATURE_TYPE         surfFeatType; 
     Dtk_feat_geometry*                      surfFeatGeometry; 
 
     /* union dtk_feat_surf_feature
     {
     OFFSET SURFACE
     SURF_PAD
     SURF_REVOL
     etc... 
     }*/
 
 
 
     //! \brief     Constructor of a Surface Feature generic feature                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated sheet Metal generic feature                         
     //! \remark                                                     
 
 
     Dtk_feat_surf_feature ();
 
 
 
     //! \brief     Destructor of a  Surface Feature generic feature                                                 
     //! \param [in]      Surface Feature Generic feature to destruct                                                  
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free  Surface Feature generic feature                          
     //! \remark    Inner test to know which kind of surface feature to disallocate                                                     
 
     ~Dtk_feat_surf_feature();
 
 
 
     //! \brief     Gets the Surface Feature type                                                     
     //! \param [in]     Surface Feature Generic feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    the Surface Feature type : enum DTK_SURF_FEATURE_TYPE                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_surf_feat_type (DTK_SURF_FEATURE_TYPE *);
 
 
 
     //! \brief   Returns inner Surface feature's output geometry                                               
     //! \param [in]   Surface Feature Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Surface Feature Inner feature's output geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
     int get_surf_feat_geometry (Dtk_feat_geometry **);
 
};
 
 
 
class Dtk_feat_sheet_metal {
 
public:
 
     DTK_SHM_FEATURE_TYPE     shm_feat_type; 
     DTK_SHM_MODULE_TYPE                shm_module_type; 
     Dtk_feat_geometry             *    unFold_output_geometry;
 
 
     /*
     union dtk_feat_shm_type {
 
 
 
     }    entity;*/
 
 
 
 
     //! \brief     Constructor of a sheet Metal generic feature                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated sheet Metal generic feature                         
     //! \remark                                                     
 
 
     Dtk_feat_sheet_metal ();
 
 
     //! \brief     Destructor of a sheet Metal generic feature                                                 
     //! \param [in]     Sheet Metal Generic feature to destruct                                                  
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free sheet Metal generic feature                          
     //! \remark    Inner test to know which kind of feature to disallocate                                                     
 
     ~Dtk_feat_sheet_metal();
 
 
 
 
     //! \brief     Gets the Sheet Metal feature type                                                     
     //! \param [in]     Sheet Metal Generic feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    the Sheet Metal feature type : enum DTK_SHM_FEATURE_TYPE                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_shm_feat_type (DTK_SHM_FEATURE_TYPE *);
 
 
 
 
     //! \brief     Gets the Sheet Metal module type                                                     
     //! \param [in]     Sheet Metal Module Generic feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    DTK_SHM_MODULE_TYPE
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_shm_module_type (DTK_SHM_MODULE_TYPE *);
 
 
 
 
 
     //! \brief   Returns inner Sheet Metal feature's unfolded output geometry                                               
     //! \param [in]   Sheet Metal Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Sheet Metal Inner feature's unfolded output geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_unFold_output_geometry (Dtk_feat_geometry **);
 
 
};
 
 
/**
@brief Neutral Fiber Segment : 
composed of the Start, End, and Center points  
or from a Spline Curve (in case of Elec3D Pipe)
*/
 
class Dtk_pipe_fiber_segment {
public:
    typedef enum {
        DTK_TOP_LEFT,
        DTK_TOP_CENTER,
        DTK_TOP_RIGHT,
        DTK_CENTER_LEFT,
        DTK_CENTER_CENTER,
        DTK_CENTER_RIGHT,
        DTK_BOTTOM_LEFT,
        DTK_BOTTOM_CENTER,
        DTK_BOTTOM_RIGHT
    }SECTION_SET_POINT;
public:
     Dtk_pnt             startPoint; 
     Dtk_pnt             endPoint; 
     Dtk_pnt             centerPoint;
     DTK_PIPE_TYPE  typeOfSegment; 
     Dtk_CurvePtr   splineCurve; 
    SECTION_SET_POINT           _sectionSetPoint;
    double                      _turnRadius; //correspond to the turnRadius after the segment
    Dtk_PlaneSurfacePtr         _orientationPlane;
     
    Dtk_pipe_fiber_segment (); 
     ~Dtk_pipe_fiber_segment(); 
 
 
 
     //! \brief   Returns fiber start Point                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     DtkErrorStatus get_start_point     ( Dtk_pnt & startPointOut) const;
 
     //! \brief   Returns fiber End Point                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     DtkErrorStatus get_end_point  ( Dtk_pnt & endPointOut) const;
 
     //! \brief   Returns fiber Center Point                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     DtkErrorStatus get_center_point    ( Dtk_pnt & centerPointOut) const;
 
     //! \brief   Returns fiber Spline Curve                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     DtkErrorStatus get_spline_curve    ( Dtk_CurvePtr& splineCurveOut) const;
 
    //! \brief   Returns pipe section set point                                                 
    //! \param [in]                                               
    //! \param [in/out]                                                   
    //! \param [out]   SECTION_SET_POINT
    //! \return     dtkErrorUnspecified if error, dtkNoError if ok                     
    //! \remark 
 
    DtkErrorStatus get_section_set_point (SECTION_SET_POINT& outSectionSetPoint) const;
 
    //! \brief   Returns Pipe Turn Radius value 
    //! \param [in]                      
    //! \param [out]   double 
    //! \return     dtkErrorUnspecified if error, dtkNoError if ok                 
    //! \remark 
    DtkErrorStatus get_TurnRadius ( double & outTurnRadius) const;
 
    //! \brief   Returns Orientation Plane 
    //! \param [in]                      
    //! \param [out]   double 
    //! \return     dtkErrorUnspecified if error, dtkNoError if ok                 
    //! \remark 
    DtkErrorStatus get_OrientationPlane ( Dtk_PlaneSurfacePtr & outOrientationPlane) const;
 
}; 
 
 
/**
@brief Pipe Section 
*/
 
class Dtk_Pipe_Section {
 
public:   
     Dtk_tab <Dtk_CurvePtr>                  profileSet;
     //Dtk_tab <Dtk_CurvePtr>                fiberSet; 
 
 
     //! \brief     Constructor of Pipe Section        
     //! \param [in/out]
     //! \param [out]    Allocated Pipe Section 
     //! \return    
     //! \remark
 
     Dtk_Pipe_Section ();
 
 
     //! \brief     Destructor of of Pipe Section 
     //! \param [in]   Pipe Section to destruct  
     //! \param [in/out]     
     //! \param [out]    
     //! \return    Free Pipe Section  
     //! \remark
 
     ~Dtk_Pipe_Section ();
 
 
     //! \brief     Get the set of the current section Profile  
     //! \param [in]   Section Profile Set    
     //! \param [in/out]     
     //! \param [out]   Dtk_tab <Dtk_CurvePtr> &
     //! \return    Error Status   
     //! \remark
 
     Dtk_ErrorStatus get_profile_set (Dtk_tab <Dtk_CurvePtr> & outProfileSet) const;
 
 
     //! \brief     Get the set of the current set of section fiber
     //! \param [in]   Section Fiber Set    
     //! \param [in/out]     
     //! \param [out]   Dtk_tab <Dtk_CurvePtr> &
     //! \return    Dtk_ErrorStatus   
     //! \remark
 
     //Dtk_ErrorStatus get_fiber_set (Dtk_tab <Dtk_CurvePtr> & outFiberSet) const;
 
 
 
};
 
class Dtk_feat_pipe {
public:
 
     DTK_PIPE_TYPE                 _type;
 
     Dtk_Pipe_Section*             _StartSection; 
     Dtk_Pipe_Section*             _EndSection; 
 
     Dtk_tab <Dtk_pipe_fiber_segment*>  neutralFiberSet; 
 
     /* More Specified data */
     DTK_PIPE_SECTION_TYPE         _sectionType;  
     double                             _Height; // a section Height, defined if the section type is : Rectangular, Flat Oval, Radius Corner, and Double Ridge
     double                             _Width;  // a section Width, defined if the section type is : Rectangular, Flat Oval, Radius Corner, and Double Ridge
     double                             _Diameter; // a section Diameter, defined if the section type is : Round 
     double                             _CornerRadius; // a section Diameter, defined if the section type is : Radius Corner 
 
     Dtk_bool                      _isClosed; 
     Dtk_tab <Dtk_pnt>             _NodeTable; 
 
    Dtk_pnt                             _StartPoint; 
    Dtk_pnt                             _EndPoint; 
 
     Dtk_feat_pipe (); 
     ~Dtk_feat_pipe(); 
 
     //! \brief   Returns pipe feature type                                                 
     //! \param [in]   Pipe Feature                                                
     //! \param [in/out]                                                   
     //! \param [out]   DTK_PIPE_TYPE
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                     
     //! \remark 
 
     Dtk_ErrorStatus get_type (DTK_PIPE_TYPE& outType) const;
 
 
     //! \brief   Returns Pipe start Point                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                   
     //! \remark 
 
     DtkErrorStatus get_start_point     ( Dtk_pnt & outStartPoint) const;
 
     //! \brief   Returns Pipe End Point                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_pnt
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
 
     DtkErrorStatus get_end_point  ( Dtk_pnt & outEndPoint) const;
 
 
 
     //! \brief   Returns pipe section type                                                 
     //! \param [in]   Pipe Feature                                                
     //! \param [in/out]                                                   
     //! \param [out]   DTK_PIPE_SECTION_TYPE
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                     
     //! \remark 
 
     Dtk_ErrorStatus get_section_type (DTK_PIPE_SECTION_TYPE& outsectionType) const;
    
 
     //! \brief   Returns Pipe start Section                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_Pipe_Section
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                   
     //! \remark 
 
     DtkErrorStatus get_start_section ( Dtk_Pipe_Section* & outStartSection) const;
 
     //! \brief   Returns Pipe End Section                                                 
     //! \param [in]                      
     //! \param [out]   Dtk_Pipe_Section
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
 
     DtkErrorStatus get_end_section     ( Dtk_Pipe_Section* & outEndSection) const;
 
 
     //! \brief   Returns Pipe is closed boolean                                                  
     //! \param [in]                      
     //! \param [out]   Dtk_bool 
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
 
     DtkErrorStatus get_is_closed  ( Dtk_bool & outIsClosed) const;
 
 
     //! \brief   Returns Pipe Section Height (Available for Rectangular, Flat Oval, Radius Corner and Double Ridge Section)                                                    
     //! \param [in]                      
     //! \param [out]   double 
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
     DtkErrorStatus get_Height     ( double & outHeight) const;
 
 
     //! \brief   Returns Pipe Section Width (Available for Rectangular, Flat Oval, Radius Corner and Double Ridge Section)                                                    
     //! \param [in]                      
     //! \param [out]   double 
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
     DtkErrorStatus get_Width ( double & outWidth) const;
 
     //! \brief   Returns Pipe Section Diameter (Available for Round Section)                                                    
     //! \param [in]                      
     //! \param [out]   double 
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
     DtkErrorStatus get_Diameter   ( double & outDiameter) const;
 
 
     //! \brief   Returns Pipe Section Radius (Available for Radius Corner Section)                                                    
     //! \param [in]                      
     //! \param [out]   double 
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
     DtkErrorStatus get_CornerRadius    ( double & outCornerRadius) const;
     
     //! \brief   Returns Table of Pipe Nodes  
     //! \param [in]                      
     //! \param [out]   Dtk_tab <Dtk_pnt>&  
     //! \return    dtkErrorUnspecified if error, dtkNoError if ok                 
     //! \remark 
     DtkErrorStatus get_NodeTable ( Dtk_tab <Dtk_pnt>& outNodeTable) const;
 
     //! \brief     Get the set of the current segments of the neutral fiber
     //! \param [in]   Section Profile Set    
     //! \param [in/out]     
     //! \param [out]   Dtk_tab <Dtk_pipe_fiber_segment*> &
     //! \return    Error Status   
     //! \remark
     Dtk_ErrorStatus get_neutral_fiber_set (Dtk_tab <Dtk_pipe_fiber_segment*> & outNeutralFiberSet) const;
};
 
 
 
/**
@brief  Spot Point (the node in the tree structure storing joint element features)
*/
class Dtk_feat_SpotPoint
{
public:
 
     enum ProcessCategory
     {
          Welding,
          Adhesive,
          Sealant        
     };
 
     enum ProcessType
     {
          Resistance,
          TIG_14,
          TIG_141,
          Laser,
          _135,
          _78,
          PLW,
          Unspecified_Welding,
 
          Structural_Adhesive,
          Non_Structural_Adhesive,
          Unspecified_Adhesive,
 
          Robot_Sealed,
          Sealed_by_hand,
          Unspecified_Sealant
     };
 
     enum Material
     {
          Glue1,
          Glue2,
          Sealant_material1,
          Sealant_material2,
          Unspecified_Material,
     };
 
     enum Robustness
     {
          Ordinary,
          Critical,
          Safety,
          Manufacturing,
          Unspecified_Robustness
     };
 
     enum Regulation
     {
          Norm_A,
          Norm_B,
          None,
          Unspecified_Regulation
     };
 
     enum Finish
     {
          Class_A,
          Class_B,
          Class_C,
          Class_D,
          Unspecified_Finish
     };
 
     //! \brief Default Constructor
     Dtk_feat_SpotPoint();
 
     //! \brief Copy Constructor
     Dtk_feat_SpotPoint(const Dtk_feat_SpotPoint & spot);
 
     //! \brief Parameters Constructor
     //! \param p_location : SpotPoint location
     //! \param p_normal : SpotPoint normal
     //! \param p_diameter : SpotPoint diameter
     //! \param p_category : SpotPoint category
     //! \param p_type : SpotPoint type
     //! \param p_robustness : SpotPoint robustness
     //! \param p_regulation : SpotPoint regulation
     //! \param p_finish : SpotPoint finish
     //! \remark in Debug throw an exception if type doesn't match category
     Dtk_feat_SpotPoint(const Dtk_pnt & p_location, 
          const Dtk_dir & p_normal, 
          double p_diameter, 
          ProcessCategory p_category, 
          ProcessType p_type, 
          Robustness p_robustness,
          Regulation p_regulation,
          Finish p_finish
          );
 
 
     //! \brief Parameters Constructor
     //! \param p_location : SpotPoint location
     //! \param p_normal : SpotPoint normal
     //! \param p_diameter : SpotPoint diameter
     //! \param p_category : SpotPoint category
     //! \param p_type : SpotPoint type
     //! \param p_robustness : SpotPoint robustness
     //! \param p_regulation : SpotPoint regulation
     //! \param p_finish : SpotPoint finish
     //! \param p_material : SpotPoint material
     //! \remark in Debug throw an exception if type doesn't match category, idem for material
     Dtk_feat_SpotPoint(const Dtk_pnt & p_location, 
          const Dtk_dir & p_normal, 
          double p_diameter, 
          ProcessCategory p_category, 
          ProcessType p_type, 
          Robustness p_robustness,
          Regulation p_regulation,
          Finish p_finish,
          Material p_material
          );
 
     //! \brief Destructor
     ~Dtk_feat_SpotPoint();
 
     //! \brief Assignment operator
     Dtk_feat_SpotPoint & operator= (const Dtk_feat_SpotPoint & spot);
 
     //! \brief   Return SpotPoint location
     Dtk_pnt location() const;
     //! \brief   Set SpotPoint location
     void setLocation(const Dtk_pnt & p_location);
     //! \brief   Returns SpotPoint location
     void setLocation(double x, double y, double z);
 
     //! \brief   Return SpotPoint normal
     Dtk_dir normal() const;
     //! \brief   Set SpotPoint normal
     void setNormal(const Dtk_dir & p_normal);
     //! \brief   Set SpotPoint normal
     void setNormal(double x, double y, double z);
 
     //! \brief   Return SpotPoint diameter
     double diameter() const;
     //! \brief   Set SpotPoint diameter
     void setDiameter(double p_diam);
 
     //! \brief   Return SpotPoint inspection flag
     bool isInspectionFlag() const;
     //! \brief   Set SpotPoint inspection flag
     void setInspectionFlag(bool p_flag);
 
     //! \brief   Return SpotPoint geometry flag
     //! \remark only available with Welding
     bool isGeometryFlag() const;
     //! \brief   Set SpotPoint geometry flag
     //! \remark only available with Welding
     void setGeometryFlag(bool p_flag);
 
     //! \brief   Return SpotPoint category
     ProcessCategory processCategory() const;
     //! \brief   Set SpotPoint category
     void setProcessCategory(ProcessCategory p_category);
     //! \brief   Set SpotPoint category
     void setProcessCategory(Dtk_string const & p_category);
 
     //! \brief   Return SpotPoint type
     ProcessType processType() const;
     //! \brief   Set SpotPoint type
     //! \remark on Debug throw an exception if type doesn't match category
     void setProcessType(ProcessType p_type);
     //! \brief   Set SpotPoint type
     //! \remark on Debug throw an exception if type doesn't match category
     void setProcessType(Dtk_string const & p_type);
 
     //! \brief   Return SpotPoint regulation
     Robustness robustness() const;
     //! \brief   Set SpotPoint robustness
     void setRobustness(Robustness p_robustness);
     //! \brief   Set SpotPoint robustness
     void setRobustness(Dtk_string const & p_robustness);
 
     //! \brief   Return SpotPoint regulation
     Regulation regulation() const;
     //! \brief   Set SpotPoint regulation
     void setRegulation(Regulation p_regulation);
     //! \brief   Set SpotPoint regulation
     void setRegulation(Dtk_string const & p_regulation);
 
     //! \brief   Return SpotPoint finish
     Finish finish() const;
     //! \brief   Set SpotPoint finish
     void setFinish(Finish p_finish);
     //! \brief   Set SpotPoint finish
     void setFinish(Dtk_string const & p_finish);
 
     //! \brief   Return SpotPoint material
     Material material() const;
     //! \brief   Set SpotPoint material
     //! \remark in Debug throw an exception if it's Welding category
     void setMaterial(Material p_material);
     //! \brief   Set SpotPoint material
     //! \remark in Debug throw an exception if it's Welding category
     void setMaterial(Dtk_string const & p_material);
 
     //! \brief   Return SpotPoint manufacturing code
     Dtk_string manufacturingCode() const;
     //! \brief   Set SpotPoint manufacturing code
     void setManufacturingCode(const Dtk_string & p_code);
 
private:
 
     Dtk_pnt m_location;
 
     Dtk_dir m_normal;
 
     Dtk_string m_manufacturing_code;
 
     double m_diameter;
 
     ProcessCategory m_category;
 
     ProcessType m_type;
 
     Robustness m_robustness;
 
     Regulation m_regulation;
 
     Finish m_finish;
 
     Material m_material;
 
     bool m_flag_inspection;
 
     bool m_flag_geometry;
 
};
 
 
/**
@brief  Generic Feature 
All metric data in feature classes are given in MM
All angular data are given in degree
*/
 
 
class Dtk_feat : public Dtk_Entity {
 
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_FEATURE
     };
 
 
 
     inline virtual Dtk_Object* Clone() { return new Dtk_feat(*this); }
     friend class Dtk_SmartPtr<Dtk_feat>;
 
 
private:
     void _Init();
     void _Copy(const Dtk_feat &s);
     void _Reset();
 
public:
     DTK_FEATURE_TYPE         type;
     long                               id;
     long                               body_id;
     //wchar_t                          *    name;
     Dtk_string                              name;
     Dtk_feat_geometry             *    input_geometry;
     Dtk_feat_geometry             *    output_geometry;
     Dtk_feat_geometry             *    associated_geometry;
     Dtk_feat_geometry             *    final_associated_geometry; 
     bool                               isActive; 
 
     union dtk_feat_type {                   
 
          /* Dress-up Features */
          Dtk_feat_thread               *    thread;
          Dtk_feat_shell           *    shell;
          Dtk_feat_fillet               *    fillet;
          Dtk_feat_face_fillet     *    face_fillet; 
          Dtk_feat_tritangent_fillet* tritangent_fillet; 
          Dtk_feat_chamfer         *    chamfer;
          Dtk_feat_draft           *    draft; 
          Dtk_feat_loft            *    loft; 
          Dtk_feat_thickness_feat  *    thickness_feat;
 
 
 
          /* Sketch-based Features */
          Dtk_feat_prism           *    prism;
          Dtk_feat_revol           *    revol;
          Dtk_feat_hole            *    hole;
          Dtk_feat_hole_series     *    hole_series;
          Dtk_feat_udf           * udf;
          Dtk_feat_sweep           *    sweep;
          Dtk_feat_multi_prism     *    multi_prism;
          Dtk_feat_remove_face     *    remove_face; 
          Dtk_feat_replace_face    *    replace_face; 
 
 
 
          /* Surface-based Features */
          Dtk_feat_split_surf      *    split;
          Dtk_feat_thick_surf      *    thick_surf;
          Dtk_feat_sew_surf        *    sew;
          Dtk_feat_close_surf      *    close;
 
          /* Transformation Features */
          Dtk_feat_pattern         *    pattern;
          Dtk_feat_user_pattern    *    user_pattern;
          Dtk_feat_mirror               *    mirror;
          Dtk_feat_translate       *    translate; 
          Dtk_feat_rotate               *    rotate; 
          Dtk_feat_stiffener       *    stiffener; 
          Dtk_feat_scaling         *    scaling; 
          Dtk_feat_symmetry        *    symmetry; 
 
          /* Boolean operations */
          Dtk_feat_boolean         *    boolean_op;
 
          /* Feature Body*/
          Dtk_feat_body            *    body; 
 
          /*Sheet Metal */
          Dtk_feat_sheet_metal          * sheet_metal;
 
          /* Surface Features*/
          Dtk_feat_surf_feature         *surf_feature; 
 
          /* User defined features */
          Dtk_feat_user_defined    *    user_defined;
 
          /* Piping and Tubing Feature*/
          Dtk_feat_pipe *                    pipe; 
 
          /*Spot Point*/
          Dtk_feat_SpotPoint *          spot_point;
 
     }    entity;
 
     //! \brief     BaseConstructor of a generic feature                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated generic feature                         
     //! \remark  
     Dtk_feat();
 
     //! \CopyConstructor{const Dtk_feat&} 
     Dtk_feat( const Dtk_feat&s );
 
     //! \brief     BaseDestructor of a generic feature                                                 
     //! \param [in]     Generic feature to destruct                                                  
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free generic feature                          
     //! \remark    Inner test to know which kind of feature to disallocate                                  
     ~Dtk_feat();
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Entity::DtkDynamicType(inId); 
     }
 
     //! \DtkDynamicCast
     static Dtk_feat* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_feat*>(s); 
          return NULL; 
     } 
 
     //! \return The type of the entity type - DTK_TYPE_FEATURE - 
     type_detk get_type_detk() const { return DTK_TYPE_FEATURE; }
 
     //! \CreateBase
     static Dtk_FeaturePtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
     //! \brief Delete object
     static Dtk_FeaturePtr release(Dtk_FeaturePtr inFeature);
 
     //! \brief     Gets the feature type                                                     
     //! \param [in]     Generic feature                                                    
     //! \param [in/out]                                                      
     //! \param [out]    the feature type : enum DTK_FEATURE_TYPE                                                     
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_type (DTK_FEATURE_TYPE *);
     DTK_FEATURE_TYPE GetType() const {return type;}
 
     Dtk_string GetTypeAsString();
     //int get_id (long *);
 
 
     //! \brief     Returns the feature name                                                         
     //! \param [in]     Generic Feature                                                         
     //! \param [in/out]                                                          
     //! \param [out]    Feature Name                                                          
     //! \return    NOTOK if error, ISOK if ok                             
     //! \remark
     int get_name (Dtk_string *);
     Dtk_string GetName() const {return name;}
 
 
     int GetId() const {return id;}
 
     //! \brief   Returns inner feature's basis geometry                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Inner feature's geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark
 
     int get_input_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetInputGeometry()const{return input_geometry;}
 
     //! \brief   Returns inner feature's output geometry                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Inner feature's output geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_output_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetOutputGeometry()const{return output_geometry;}
 
     //! \brief   Returns inner feature's associated geometry                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Inner feature's associated geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_associated_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetAssociatedGeometry()const{return associated_geometry;}
 
 
     //! \brief   Returns inner feature's final associated geometry, i.e. geometry that appears on the final Brep model                                              
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Inner feature's final associated geometry                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_final_associated_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetFinalAssociatedGeometry()const{return final_associated_geometry;}
 
 
     //! \brief   Returns inner feature's activation status                                                
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Inner feature's activation status (bool)                                                   
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark 
 
     int get_isActive (bool *);
    Dtk_bool IsActive() const {return isActive;}
 
 
 
     //! \brief     Returns feature's inner Hole Feature                                                  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Hole Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call  
 
     int get_hole                  ( Dtk_feat_hole **e);
     Dtk_feat_hole *GetHole()const{return entity.hole;}
     Dtk_feat_hole_series *GetHoleSeries()const{return entity.hole_series;}
     Dtk_feat_udf *GetUdf()const{return entity.udf;}
 
 
     //! \brief   Returns feature's inner Thread Feature                                                    
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Thread Feature                                                
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call 
 
     int get_thread                ( Dtk_feat_thread **e);
     Dtk_feat_thread *GetThread()const{return entity.thread;}
 
 
 
     //! \brief   Returns feature's inner Shell Feature                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Shell Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_shell                 ( Dtk_feat_shell **e);
     Dtk_feat_shell *GetShell()const{return entity.shell;}
 
 
     //! \brief   Returns feature's inner Fillet Feature                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Fillet Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_fillet                ( Dtk_feat_fillet **e);
     Dtk_feat_fillet *GetFillet()const{return entity.fillet;}
 
 
 
     //! \brief   Returns feature's inner Face Fillet Feature                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Face Fillet Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_face_fillet                ( Dtk_feat_face_fillet **e);
     Dtk_feat_face_fillet *GetFaceFillet()const{return entity.face_fillet;}
 
 
 
     //! \brief   Returns feature's inner Tri-tangent Fillet Feature                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Face Fillet Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_tritangent_fillet          ( Dtk_feat_tritangent_fillet **e);
     Dtk_feat_tritangent_fillet *GetTriTangentFillet()const{return entity.tritangent_fillet;}
 
 
 
 
     //! \brief   Returns feature's inner Prism Feature (PAD|POCKET)                                              
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Prism Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_prism                 ( Dtk_feat_prism **e);
     Dtk_feat_prism *GetPrism()const{return entity.prism;}
 
 
 
 
     //! \brief   Returns feature's inner Multi Prism Feature (MULTI_PAD|MULTI_POCKET)                                              
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Multi Prism Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_multi_prism                ( Dtk_feat_multi_prism **e);
     Dtk_feat_multi_prism *GetMultiPrism()const{return entity.multi_prism;}
 
 
 
     //! \brief   Returns feature's inner Revol Feature (SHAFT|GROOVE)                                              
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Revol Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_revol                 ( Dtk_feat_revol **e);
     Dtk_feat_revol *GetRevol()const{return entity.revol;}
 
 
     //! \brief   Returns feature's inner Sweep Feature (RIB|SLOT)                                               
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Sweep Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call 
 
     int get_sweep                 ( Dtk_feat_sweep **e);
     Dtk_feat_sweep *GetSweep()const{return entity.sweep;}
 
 
     //! \brief   Returns feature's inner Chamfer Feature
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Chamfer Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_chamfer                    ( Dtk_feat_chamfer **e);
     Dtk_feat_chamfer *GetChamfer()const{return entity.chamfer;}
 
 
 
     //! \brief   Returns feature's inner Draft Feature
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Draft Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_draft                 ( Dtk_feat_draft **e);
     Dtk_feat_draft *GetDraft()const{return entity.draft;}
 
 
 
     //! \brief   Returns feature's inner mirror feature
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Mirror Feature                                               
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_mirror                ( Dtk_feat_mirror **e);
     Dtk_feat_mirror *GetMirror()const{return entity.mirror;}
 
 
 
     //! \brief   Returns feature's inner pattern feature (Rectangular & Circular)
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   pattern Feature (Rectangular & Circular)                                              
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_pattern                    ( Dtk_feat_pattern **e);
     Dtk_feat_pattern *GetPattern()const{return entity.pattern;}
 
 
 
 
     //! \brief   Returns feature's inner user pattern feature 
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   user pattern Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_user_pattern     ( Dtk_feat_user_pattern **e);
     Dtk_feat_user_pattern *GetUserPattern()const{return entity.user_pattern;}
 
 
 
     //! \brief   Returns feature's inner boolean operation feature 
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   boolean Operation Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_boolean_operation ( Dtk_feat_boolean **e);
     Dtk_feat_boolean *GetBooleanOperation()const{return entity.boolean_op;}
 
 
 
     //! \brief   Returns feature's body  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Body Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_body ( Dtk_feat_body **e);
     Dtk_feat_body *GetFeatBody()const{return entity.body;}
 
 
 
     //! \brief   Returns feature's inner split surface feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Split Surface Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_split_surf ( Dtk_feat_split_surf **e);
     Dtk_feat_split_surf *GetSplitSurface()const{return entity.split;}
 
 
 
 
     //! \brief   Returns feature's inner close (fill) surface feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Close Surface Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_close_surf ( Dtk_feat_close_surf **e);
     Dtk_feat_close_surf *GetCloseSurface()const{return entity.close;}
 
 
 
     //! \brief   Returns feature's inner sew surface feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Sew Surface Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_sew_surf ( Dtk_feat_sew_surf **e);
     Dtk_feat_sew_surf *GetSewSurface()const{return entity.sew;}
 
 
 
     //! \brief   Returns feature's inner remove face feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Remove Face Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_remove_face ( Dtk_feat_remove_face **e);
     Dtk_feat_remove_face *GetRemoveFace()const{return entity.remove_face;}
 
 
 
     //! \brief   Returns feature's inner replace face feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Replace Face Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_replace_face ( Dtk_feat_replace_face **e);
     Dtk_feat_replace_face *GetReplaceFace()const{return entity.replace_face;}
 
 
 
 
     //! \brief   Returns feature's translate feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Generic Translate Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_translate ( Dtk_feat_translate **e);
     Dtk_feat_translate *GetTranslate()const{return entity.translate;}
 
 
 
     //! \brief   Returns feature's rotate feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Generic Rotate Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_rotate ( Dtk_feat_rotate **e);
     Dtk_feat_rotate *GetRotate()const{return entity.rotate;}
 
 
 
 
     //! \brief   Returns feature's symmetry feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Generic Rotate Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_symmetry ( Dtk_feat_symmetry **e);
     Dtk_feat_symmetry *GetSymmetry()const{return entity.symmetry;}
 
 
 
 
     //! \brief   Returns feature's stiffener feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Generic Stiffener Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_stiffener ( Dtk_feat_stiffener **e);
     Dtk_feat_stiffener *GetStiffener()const{return entity.stiffener;}
 
 
 
 
     //! \brief   Returns feature's scaling feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Generic Scaling Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_scaling ( Dtk_feat_scaling **e);
     Dtk_feat_scaling *GetScaling()const{return entity.scaling;}
 
 
 
 
     //! \brief   Returns feature's Sheet Metal feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Sheet Metal Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_sheet_metal  ( Dtk_feat_sheet_metal **e);
     Dtk_feat_sheet_metal *GetSheetMetal()const{return entity.sheet_metal;}
 
 
 
     //! \brief   Returns feature's Surface feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]    Surface Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_surf_feature ( Dtk_feat_surf_feature **e);
     Dtk_feat_surf_feature *GetSurfaceFeature()const{return entity.surf_feature;}
 
 
 
 
     //! \brief   Returns feature's Loft feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Loft Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_loft  ( Dtk_feat_loft **e);
     Dtk_feat_loft *GetLoft()const{return entity.loft;}
 
 
 
     //! \brief   Returns feature's (Face) Thickness feature  
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Thickness Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_thickness_feat  ( Dtk_feat_thickness_feat **e);
     Dtk_feat_thickness_feat *GetThicknessFeature()const{return entity.thickness_feat;}
 
 
     //! \brief   Returns feature's inner Pipe sub-feature 
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   Pipe Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_pipe ( Dtk_feat_pipe **e);
     Dtk_feat_pipe *GetPipe()const{return entity.pipe;}
 
     Dtk_feat_user_defined  *GetUserDefined() const {return entity.user_defined;}
 
 
     //! \brief   Returns SpotPoint feature 
     //! \param [in]   Generic Feature                                               
     //! \param [in/out]                                                  
     //! \param [out]   SpotPoint Feature 
     //! \return    NOTOK if error, ISOK if ok                     
     //! \remark   You should test Generic Feature type before call
 
     int get_spot_point ( Dtk_feat_SpotPoint *&e);
     Dtk_feat_SpotPoint *GetSpotPoint()const{return entity.spot_point;}
 
};
 
 
 
 
 
/* End of generic feature */
 
/**
@brief  Node (the node in the tree structure storing the data features)
*/
 
 
class Dtk_feat_node {
 
public:
 
     NODE_TYPE           type; 
     long           id;
     Dtk_string          name;
     //Dtk_feat     *    feature; 
     Dtk_FeaturePtr feature;
     Bool           isTreated; 
 
 
 
 
     //! \brief     Constructor of a node                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated node                          
     //! \remark                                                     
 
 
     Dtk_feat_node();
 
 
 
 
     //! \brief     Destructor of a node                                                
     //! \param [in]     Generic node to destruct                                                  
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free node                          
     //! \remark                                                         
 
     ~Dtk_feat_node();
 
 
 
 
     //! \brief     Gets the node type                                                     
     //! \param [in]     Node node                                                    
     //! \param [in/out]                                                      
     //! \param [out]    NODE_TYPE                                        
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    You need to test the type to get the inner feature                                                     
 
     int get_type (NODE_TYPE *);
 
 
 
 
     //! \brief     Get the id if the node is Root type                                                    
     //! \param [in]     Node                                                   
     //! \param [in/out]                                                      
     //! \param [out]    long                                                 
     //! \return    NOTOK if error, ISOK if ok                                                                         
     //! \remark    
 
     int get_id (long *);
 
 
 
     //! \brief     Returns the root name                                                         
     //! \param [in]     Generic Root                                                         
     //! \param [in/out]                                                          
     //! \param [out]    Body Name                                                          
     //! \return    NOTOK if error, ISOK if ok                             
     //! \remark
 
     int get_name (Dtk_string *);
 
 
 
     //! \brief     Returns the feature , valid if the node is feature type                                                          
     //! \param [in]     Node                                                         
     //! \param [in/out]                                                          
     //! \param [out]    Dtk_feat                                                          
     //! \return    NOTOK if error, ISOK if ok                             
     //! \remark
 
     int get_feature (Dtk_FeaturePtr &);
 
 
 
     //! \brief     Returns the value indicating whether the node is treated or not                                                         
     //! \param [in]     Node                                                         
     //! \param [in/out]                                                          
     //! \param [out]    Dtk_feat                                                          
     //! \return    NOTOK if error, ISOK if ok                             
     //! \remark
 
     int get_isTreated (Bool*);
}; 
 
#endif