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;
 
 
 
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
 
 
};
 
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...     
}; 
 
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            
};
 
/************************************
* 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;
 
 
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 ();
 
     SetAsDeprecated("Undefined", "Use GetNodeConnectors")
     int  get_ids        (long **, int*);
 
     SetAsDeprecated("Undefined", "Use GetNodeConnectors")
     Dtk_tab<Dtk_Int32> GetAllGeomIds() const;
 
 
 
     int get_NodeConnector (Dtk_NodeConnectorPtr & outNodeConnector) const;
 
     Dtk_ErrorStatus GetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> & outNodeConnector) const;
 
     Dtk_ErrorStatus SetNodeConnectors (Dtk_tab<Dtk_NodeConnectorPtr> inTabConnectors);
 
} ;
 
class Dtk_feat_axis {
 
public :
     Dtk_dir             direction;
     Dtk_pnt             origin;
     Bool           reverse;
public:
 
 
     Dtk_feat_axis ();
     ~Dtk_feat_axis ();
 
 
     int get_origin (Dtk_pnt *);
     Dtk_pnt GetOrigin() const {return origin;}
 
 
 
     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();
 
} ;
 
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();
 
 
     int get_type (LIMIT_TYPE *);
     Dtk_string GetTypeAsString() const;
     LIMIT_TYPE GetType() const {return type;}
 
 
     int get_val (double *);
     Dtk_Double64 GetVal() const {return val;}
 
 
 
     int get_reference_object (Dtk_feat_geometry  **);
     Dtk_feat_geometry   *GetRefenceObject()const {return reference_object;}
 
 
 
} ;
 
 
class Dtk_feat_thickness_face {
public:
 
     Dtk_feat_geometry   *    face;     
     double                        thickness;
 
 
 
 
     Dtk_feat_thickness_face ();
 
 
 
     ~Dtk_feat_thickness_face ();
 
 
 
     int get_face (Dtk_feat_geometry **);
 
 
 
     int get_thickness (double *);
 
} ;
 
 
class Dtk_feat_thickness {
 
public:
     double                   thickThin1;
     double                   thickThin2;
     Bool                thick;
     Bool                neutralFiber;
     Bool                mergeThin;
 
     Dtk_feat_thickness ();
     ~Dtk_feat_thickness ();
 
 
     int get_thick (Bool *);
 
 
     int get_neutral_fiber (Bool *);
 
 
     int get_thin1 (double *);
 
 
     int get_thin2 (double *);
     int get_merge_thin (Bool *);
 
} ;
 
 
class Dtk_feat_shell_face {
public:
 
     Dtk_feat_geometry   *    face;
 
     double                   inside_thickness;
     double                   outside_thickness;
 
 
 
     Dtk_feat_shell_face ();
 
 
     ~Dtk_feat_shell_face ();
 
 
     int get_face (Dtk_feat_geometry **);
 
 
     int get_inside_thickness (double *);
 
 
     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                 *
*************************************/
 
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 :
 
 
 
 
     Dtk_feat_prism ();
 
 
 
     ~Dtk_feat_prism ();
 
 
 
     int get_type                  (DTK_PRISM_TYPE *);
 
 
 
     int  get_sym                       (Bool *);
 
 
 
     int get_inner_side            (int *);
 
 
 
     int  get_axis                 (Dtk_feat_axis **);
 
 
 
     int  get_direction_reversed   (Bool *);
 
 
 
     int  get_start_limit               (Dtk_feat_limit **);
 
 
 
     int  get_end_limit            (Dtk_feat_limit **);
 
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
 
 
     int get_thickness (Dtk_feat_thickness **);
};
 
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:
 
 
 
 
     Dtk_feat_revol ();
 
 
 
     ~Dtk_feat_revol ();
 
 
 
     int get_type                  (DTK_REVOL_TYPE *);
 
 
 
     int  get_start_angle               (double *);
 
 
 
     int  get_end_angle            (double *);
 
 
 
     int  get_reference_axis       (Dtk_feat_axis **);
 
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
 
 
     int get_thickness             (Dtk_feat_thickness **);
 
 
     int get_inner_side            (int*);
 
};
 
 
class Dtk_feat_chamfer_ribbon {
 
public:
 
     Dtk_feat_geometry   **   objects;
     int                           nb_objects;
     Bool                     reverse;
 
     Dtk_feat_chamfer_ribbon ();
     ~Dtk_feat_chamfer_ribbon ();
 
 
 
     int get_nb_objects (int *);
 
 
 
     int get_objects (Dtk_feat_geometry ***);
 
 
 
     int get_reverse (Bool *);
 
} ;
 
 
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 ();
 
 
 
     int get_nb_ribbons (int *);
 
 
 
     int get_ribbons (Dtk_feat_chamfer_ribbon     ***);
 
 
 
     int get_propagation (PROPAGATION_TYPE*);
 
 
 
     int get_type (CHAMFER_TYPE*);
 
 
 
 
     int  get_angle (double *a);
 
 
 
 
     int  get_length1 (double *a);
 
 
 
 
     int  get_length2 (double *a);
 
} ;
 
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:
 
 
 
 
     Dtk_feat_inner_thread ();
 
 
 
     ~Dtk_feat_inner_thread ();
 
 
 
     int get_diameter         (double *);
     Dtk_Double64 GetDiameter() const {return  thread_params[IND_DIAMETER];}
 
 
 
     int get_diameter_with_tol     (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDiameterTolerance() const {return tol_thread_params[IND_DIAMETER]; }
 
 
 
     int get_diameter_has_tol (Bool *);
     Dtk_bool HasDiameterTolerance()const {return !(tol_thread_params[IND_DIAMETER] == NULL);}
 
 
 
     int get_depth            (double *);
     Dtk_Double64 GetDepth() const {return  thread_params[IND_DEPTH];}
 
     int get_depth_with_tol        (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDepthTolerance() const {return tol_thread_params[IND_DEPTH]; }
 
 
     int get_depth_has_tol    (Bool *);
     Dtk_bool HasDepthTolerance()const {return !(tol_thread_params[IND_DEPTH] == NULL);}
 
     int get_pitch            (double *);
     Dtk_Double64 GetPitch() const {return  thread_params[0];}
 
 
     int get_pitch_with_tol        (double *, double *, double *);
     Dtk_feat_tolerance_set *GetPitchTolerance() const {return tol_thread_params[0]; }
 
 
     int get_pitch_has_tol    (Bool *);
     Dtk_bool HasPitchTolerance()const {return !(tol_thread_params[IND_DEPTH] == NULL);}
 
 
     int get_right_threaded   (Bool *);
     Dtk_bool IsRightThreaded() const {return right_threaded;}
     Dtk_bool IsNoStandardTable() const {return no_standard_table;}
     
 
     SetAsDeprecated("2024.2", "Use GetDefinitionType()")
     int get_def_type    (wchar_t **);
     Dtk_string GetDefinitionType() const {return thread_definition_type; }
 
     SetAsDeprecated("2024.2", "Use GetDefinitionValue()")
     int get_def_value        (wchar_t **);
     Dtk_string GetDefinitionValue() const {return thread_definition_value; }
 
 
     int get_thread_type      (DTK_THREAD_TYPE&);
     Dtk_string GetTypeAsString() const;
     DTK_THREAD_TYPE GetType() const {return thread_type;}
     
 
 
     int get_thread_limit_type          (DTK_THREAD_LIMIT_TYPE&);
     Dtk_string GetLimitTypeAsString() const;
     DTK_THREAD_LIMIT_TYPE GetLimitType() const {return thread_limit_type;}
 
 
     int get_thread_limit_reference          (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetLimitReference() const {return thread_limit_reference;}
 
} ;
 
 
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 :
 
 
 
     Dtk_feat_thread ();
 
 
     ~Dtk_feat_thread ();
 
 
     int get_inner_thread                                   (Dtk_feat_inner_thread **);
     Dtk_feat_inner_thread *GetInnerThread()const{return inner_thread;}
 
 
     int  get_support                        (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetSupport()const{return support;}
          
 
 
     int get_support_depth                                  (double *);
     Dtk_Double64 GetSupportDepth() const{return support_depth;}
 
 
     int get_support_depth_with_tol                         (double *, double *, double *);
     Dtk_feat_tolerance_set *GetSupportDepthTolerance() const{return tol_support_depth;}
 
 
     int get_support_depth_has_tol                     (Bool *);
     Dtk_bool HasSupportDepthTolerance() const{return !(tol_support_depth == NULL);}
 
 
     int get_support_diameter                          (double *);
     Dtk_Double64 GetSupportDiameter() const{return support_diameter;}
 
 
     int get_support_diameter_with_tol                 (double *, double *, double *);
     Dtk_feat_tolerance_set *GetSupportDiameterTolerance() const{return tol_support_diameter;}
 
 
     int get_support_diameter_has_tol                  (Bool *);
     Dtk_bool HasSupportDiameterTolerance() const{return !(tol_support_diameter == NULL);}
 
 
     int  get_limit                                         (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetLimit()const{return face_limit;}
 
 
     int get_direction_reversed                             (Bool *);
     Dtk_bool IsReversed()const{return direction_reversed;}
 
} ;
 
/* End Feature Thread */
 
 
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 :
 
 
 
     Dtk_feat_hole();
 
 
     ~Dtk_feat_hole();
 
 
 
     int get_type             (HOLE_TYPE *);
     HOLE_TYPE GetType() const {return hole_type;}
     Dtk_string GetTypeAsString() const;
 
 
     int  get_anchor_type     (ANCHOR_TYPE *);
     Dtk_string GetAnchorTypeAsString() const;
 
 
     int  get_bottom_type     (HOLE_BOTTOM_TYPE *);
     Dtk_string GetThreadBottomTypeAsString() const;
 
 
     int get_threaded         (Bool *);
     Dtk_bool IsThreaded()const {return hole_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;}
 
 
     int  get_axis            (Dtk_feat_axis **);
     Dtk_feat_axis *GetAxis() const {return axis;}
 
 
     int  get_limit           (Dtk_feat_limit **);
     Dtk_feat_limit *GetLimit() const {return hole_limit;}
 
 
     int  get_diameter        (double *);
     Dtk_Double64 GetDiameter() const {return  hole_params[IND_DIAMETER];}
 
 
     int get_diameter_with_tol     (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDiameterTolerance() const {return tol_hole[IND_DIAMETER]; }
 
 
 
     int get_diameter_has_tol (Bool *);
     Dtk_bool HasDiameterTolerance()const {return !(tol_hole[IND_DIAMETER] == NULL);}
 
 
     int get_depth            (double *);
     Dtk_Double64 GetDepth() const {return  hole_params[IND_DEPTH];}
 
 
     int get_depth_with_tol   (double *, double *, double *);
     Dtk_feat_tolerance_set *GetDepthTolerance() const {return tol_hole[IND_DEPTH]; }
 
 
 
     int get_depth_has_tol    (Bool *);
     Dtk_bool HasDepthTolerance()const {return !(tol_hole[IND_DEPTH] == NULL);}
 
 
     int get_bottom_angle     (double *);
     Dtk_Double64 GetBottomAngle() const {return  hole_params[IND_ANGLE];}
 
 
 
     int get_bottom_angle_with_tol (double *, double *, double *);
     Dtk_feat_tolerance_set *GetBottomAngleTolerance() const {return tol_hole[IND_ANGLE]; }
 
 
     int get_bottom_angle_has_tol  (Bool *);
     Dtk_bool HasBottomAngleTolerance()const {return !(tol_hole[IND_ANGLE] == NULL);}
 
 
     int get_counter_diameter ( double *);
     Dtk_Double64 GetCounterDiameter() const {return  counter_params[IND_DIAMETER];}
 
 
 
     int get_sunk_diameter ( double *);
     Dtk_Double64 GetSunkDiameter() const {return  Sunk_diameter;}
 
 
     int get_counter_diameter_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterDiameterTolerance() const {return tol_counter[IND_DIAMETER]; }
 
 
 
     int get_counter_diameter_has_tol   (Bool *);
     Dtk_bool HasCounterDiameterTolerance()const {return !(tol_counter[IND_DIAMETER] == NULL);}
 
 
 
     int get_counter_depth ( double *);
     Dtk_Double64 GetCounterDepth() const {return  counter_params[IND_DEPTH];}
 
 
     int get_counter_depth_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterDepthTolerance() const {return tol_counter[IND_DEPTH]; }
 
 
     int get_counter_depth_has_tol (Bool *);
     Dtk_bool HasCounterDepthTolerance()const {return !(tol_counter[IND_DEPTH] == NULL);}
 
 
 
     int get_counter_angle ( double *);
     Dtk_Double64 GetCounterAngle() const {return  counter_params[IND_ANGLE];}
 
 
     int get_counter_angle_with_tol ( double *, double *, double *);
     Dtk_feat_tolerance_set *GetCounterAngleTolerance() const {return tol_counter[IND_ANGLE]; }
 
 
 
     int get_counter_angle_has_tol (Bool *);
     Dtk_bool HasCounterAngleTolerance()const {return !(tol_counter[IND_ANGLE] == NULL);}
 
     int get_annotation ( Dtk_pnt *, char *);
 
     Dtk_Int32 IsStartActived() const {return start_active;}
 
     Dtk_Double64 GetStartAngle() const {return  start_params[IND_ANGLE];}
 
     Dtk_Double64 GetStartDiameter() const {return  start_params[IND_DIAMETER];}
 
 
     Dtk_Int32 IsReliefActived() const {return relief_active;}
 
     Dtk_Double64 GetReliefAngle() const {return  relief_params[IND_ANGLE];}
 
     Dtk_Double64 GetReliefDiameter() const {return  relief_params[IND_DIAMETER];}
 
     Dtk_Double64 GetReliefDepth() const {return  relief_params[IND_DEPTH];}
 
     Dtk_Int32 IsNeckActived() const {return neck_active;}
 
     Dtk_Double64 GetNeckAngle() const {return  neck_params[IND_ANGLE];}
 
     Dtk_Double64 GetNeckDiameter() const {return  neck_params[IND_DIAMETER];}
 
     Dtk_Double64 GetNeckDepth() const {return  neck_params[IND_DEPTH];}
 
     Dtk_Int32 IsEndActived() const {return end_active;}    
     
     Dtk_Double64 GetEndAngle() const {return  end_params[IND_ANGLE];}
 
     Dtk_Double64 GetEndDiameter() const {return  end_params[IND_DIAMETER];}
 
} ;
/* Fin Feature hole */
 
 
class Dtk_feat_hole_series {
 
public:
 
     Dtk_FeaturePtr          _Start ;
     Dtk_FeaturePtr          _Middle ;
     Dtk_FeaturePtr          _End ;
 
public :
 
 
 
     Dtk_feat_hole_series();
 
 
     ~Dtk_feat_hole_series();
 
     void get_dtk_feat_hole_series_start     (Dtk_FeaturePtr& out);
 
     void get_dtk_feat_hole_series_middle    (Dtk_FeaturePtr& out);
 
     void get_dtk_feat_hole_series_end       (Dtk_FeaturePtr& out);
     
 
 
} ;
/* Fin Feature hole */
 
class Dtk_feat_udf {
 
public:
 
     Dtk_FeaturePtr          _Feature ;
     Dtk_string              _XmlDefinition ;
 
public :
 
 
 
     Dtk_feat_udf();
 
 
     ~Dtk_feat_udf();
 
     void get_dtk_feat_udf_feature (Dtk_FeaturePtr& out);
 
     void get_dtk_feat_udf_xmldefinition(Dtk_string& out);
 
} ;
/* Fin Feature hole */
 
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;
 
 
 
     Dtk_feat_shell ();
 
 
     ~Dtk_feat_shell();
 
 
     int get_inside_thickness ( double *);
 
 
     int get_outside_thickness ( double *); 
 
 
     int get_nb_removed_faces ( int *);
 
 
     int get_nb_skins ( int *);
 
 
     int get_removed_faces ( Dtk_feat_shell_face*** );
 
 
     int get_skins ( Dtk_feat_shell_face*** );
 
} ;
 
/* End feature Shell */
 
class Dtk_feat_cst_edge_ribbon {
public:
 
     double                   cst_radius;
 
     Dtk_feat_cst_edge_ribbon();
     ~Dtk_feat_cst_edge_ribbon();
 
 
     int get_radius (double *);
 
} ;
 
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 ();
 
 
     int  get_elt ( Dtk_feat_geometry **);
 
 
     int  get_point ( Dtk_pnt*);
 
 
     int  get_radius ( double *);
 
 
     int  get_ratio ( double *);
 
 
 
} ;
 
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();
 
 
     int get_nb_points ( int *);
 
 
     int get_points ( Dtk_feat_fillet_point***);
     int get_variation (FILLET_VARIATION_TYPE *);
 
};
 
 
 
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();
 
     SetAsDeprecated("Undefined", "Use GetPropagationType")
     int  get_propagation ( Bool *); 
 
    PROPAGATION_TYPE GetPropagationType() const;
 
 
     int  get_elts ( Dtk_feat_geometry** *);
 
 
     int get_nb_elts ( int *);
 
 
     int get_cst_ribbon (Dtk_feat_cst_edge_ribbon**);
 
 
     int get_var_ribbon (Dtk_feat_var_edge_ribbon**);
 
 
 
 
} ;
 
 
class Dtk_feat_blend_vertex {
 
public:
 
     Dtk_feat_geometry        *    corner;
     double                        set_back_distance;
 
     Dtk_feat_blend_vertex();
     ~Dtk_feat_blend_vertex();
 
 
     int  get_corner ( Dtk_feat_geometry **);
 
 
     int  get_set_back_distance ( double*);
 
} ;
 
 
 
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 ();
 
 
     int  get_type ( FILLET_TYPE *);
 
 
     int  get_propagation ( PROPAGATION_TYPE *);
 
 
     int  get_nb_objects_to_fillet ( int *);
 
 
     int  get_nb_limits ( int *) ;
 
 
     int  get_nb_corners ( int *);
 
 
     int  get_corners ( Dtk_feat_blend_vertex** *);
 
 
     int  get_limiting_list ( Dtk_feat_geometry** *);
 
 
     int  get_objects_to_fillet ( Dtk_feat_edge_ribbon** *);
 
 
     int  get_trim_ribbon_mode ( Bool *);
 
 
};
 
 
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 ();
 
 
 
     int  get_radius ( double *);
 
 
 
     int  get_face1 ( Dtk_feat_geometry**);
 
 
 
 
     int  get_face2 ( Dtk_feat_geometry**);
 
 
 
 
     int  get_limiting_element ( Dtk_feat_geometry**);
 
 
 
     int  get_hold_curve ( Dtk_feat_geometry**);
 
 
 
 
     int  get_spine ( Dtk_feat_geometry**);
 
};
 
 
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 ();
 
 
 
 
     int  get_face1 ( Dtk_feat_geometry**);
 
 
 
 
     int  get_face2 ( Dtk_feat_geometry**);
 
 
 
     int  get_remove_face ( Dtk_feat_geometry**);
 
 
 
 
     int  get_limiting_element ( Dtk_feat_geometry**);
 
};
 
 
 
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();
 
 
     int get_type ( DTK_SWEEP_TYPE *);
 
 
     int get_thickness ( Dtk_feat_thickness **); 
 
 
     int get_nb_profiles ( int *); 
 
 
     int get_profiles ( Dtk_feat_geometry *** ); 
 
 
     int get_center_curve ( Dtk_feat_geometry ** ); 
 
 
     int get_merge_ends ( Bool * ); 
 
 
     int get_profile_control_type ( PROFILE_CONTROL_TYPE * ); 
 
 
     int get_axis ( Dtk_feat_axis ** );
 
 
     int get_control_object_selection ( Dtk_feat_geometry ** );
 
 
     int get_control_object_axis ( Dtk_feat_axis ** ); 
} ;
 
 
 
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(); 
 
 
 
 
     int get_split_element  (Dtk_feat_geometry* *);
 
 
 
     int get_side  (Bool *);
};
 
 
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(); 
 
 
 
     int get_surface  (Dtk_feat_geometry* *);
 
 
 
     int get_first_offset  (double *);
 
 
 
     int get_second_offset  (double *);
 
 
 
 
     int get_sens_offset (Bool *);
}; 
 
 
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(); 
};
 
 
class Dtk_feat_close_surf {
 
public: 
 
     Dtk_feat_geometry        *         surf;
     double                                  tolerance;
 
     Dtk_feat_close_surf(); 
     ~Dtk_feat_close_surf(); 
 
 
 
     int get_surface  (Dtk_feat_geometry* *);
 
 
 
 
     int get_tolerance  (double *);
 
};
 
class Dtk_feat_remove_face {
 
public: 
 
     Dtk_tab <Dtk_feat_geometry*>       faces_to_remove; 
     Dtk_tab <Dtk_feat_geometry*>       faces_to_keep; 
 
 
 
 
     Dtk_feat_remove_face(); 
 
 
 
 
 
     ~Dtk_feat_remove_face(); 
 
 
 
     int get_faces_to_remove (Dtk_tab <Dtk_feat_geometry*>& );
 
 
 
     int get_faces_to_keep (Dtk_tab <Dtk_feat_geometry*>& );
 
 
 
 
     int get_removed_faces_nb (int*);
 
 
 
     int get_kept_faces_nb (int*);
 
};
 
 
class Dtk_feat_replace_face {
 
public: 
 
     Dtk_feat_geometry*       face_to_remove; 
     Dtk_feat_geometry*       replacing_surface; 
 
 
 
 
 
     Dtk_feat_replace_face(); 
 
 
 
 
 
     ~Dtk_feat_replace_face(); 
 
 
 
     int get_face_to_remove (Dtk_feat_geometry**);
 
 
 
 
     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();
 
 
 
 
     int get_nb_instances  (int *);
 
 
 
 
     int get_spacing  (double *);
 
 
 
 
     int get_length   (double *);
 
 
 
 
     int get_direction   (Dtk_feat_axis **);
 
 
 
     int get_reverse   (Bool *);
 
     int get_is_equal_spacing ( Dtk_bool * );
     
     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();
 
 
 
 
     int get_first_dir   (Dtk_feat_pattern_dir **);
 
 
 
     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();
 
 
 
 
 
     int get_axial_reference   (Dtk_feat_pattern_dir **);
 
 
 
 
     int get_radial_alignment  (Bool *);
 
 
 
 
     int get_nb_circles  (int *);
 
 
 
     int get_circle_spacing  (double *);
 
 
 
     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();
 
 
 
 
 
     int get_type  (DTK_PATTERN_TYPE *);
 
 
 
 
     int get_object_type ( DTK_OBJECT_TYPE *);
 
 
 
 
     int get_objects_to_pattern ( Dtk_tab<Dtk_feat_geometry *> &); 
 
 
 
 
     int get_nb_objects_to_pattern ( int *); 
 
 
 
 
     int get_nb_input_ids ( int *);
 
 
 
 
     int get_input_ids ( Dtk_tab<long> &);
 
 
 
     int get_nb_features ( int *);
 
 
 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> & );
 
 
 
 
 
     int get_gener_tool ( bool *);
 
 
 
 
     int get_simple_rep ( Bool *);
 
 
 
 
 
     int get_nb_instances ( int *);
 
 
 
     int get_active_instances ( Bool **);
 
 
 
 
     int get_row1 ( int *);
 
 
 
 
     int get_row2 ( int *);
 
 
 
 
 
     int get_angle ( double *);
 
 
 
 
     int get_keep_spec( Bool *);
 
 
 
 
     int get_rect_pattern ( Dtk_feat_rect_pattern **);
 
 
 
 
     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();
 
 
 
 
     int get_object_to_pattern ( Dtk_feat_geometry**); 
 
 
 
 
     int get_keep_spec( Bool *);
 
 
 
 
     int get_anchor_point  ( Dtk_feat_geometry**); 
 
 
 
 
     int get_nb_points ( int *); 
 
 
 
     int get_points ( Dtk_tab <Dtk_pnt> &); 
 
 
 
     int get_nb_features ( int *);
 
 
 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> & );
 
 
 
 
     int get_gener_tool ( bool *);
 
 
 
     int get_nb_input_ids ( int *);
 
 
 
 
     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(); 
 
 
 
     int get_element_geometry  ( Dtk_feat_geometry **);
 
 
 
     int get_element_id  ( long*);
 
 
 
     //int get_hide_Intitial_Element( bool*);
 
 
 
     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();
 
 
 
 
 
     int get_isMirror  ( bool *);
 
 
 
 
     int get_object_type ( DTK_OBJECT_TYPE *);
 
 
 
     int get_object_to_mirror ( Dtk_feat_geometry***); 
 
 
 
 
     int get_nb_elts ( int *); 
 
 
 
 
     int get_reference ( Dtk_feat_geometry**); 
 
 
 
 
     int get_nb_input_ids ( int *);
 
 
 
 
     int get_input_ids ( long**);
 
 
 
 
     int get_nb_features ( int *);
 
 
 
 
     int get_features ( Dtk_tab<Dtk_FeaturePtr> &);
 
 
 
 
 
     int get_gener_tool ( bool *);
 
 
} ;
 
class Dtk_feat_symmetry {
 
public: 
 
     Dtk_feat_geometry*       reference; 
 
 
 
 
     Dtk_feat_symmetry(); 
 
 
 
 
 
     ~Dtk_feat_symmetry(); 
 
 
 
     int get_reference (Dtk_feat_geometry**);
 
};
 
 
 
class Dtk_feat_translate_direction 
{
public: 
     Dtk_feat_axis       * direction; 
     double                   distance; 
 
 
 
     Dtk_feat_translate_direction ();
 
 
 
     ~Dtk_feat_translate_direction (); 
 
 
 
     int  get_direction ( Dtk_feat_axis **);
 
 
 
 
     int  get_distance ( double *);
 
 
};
 
 
 
class Dtk_feat_translate_point 
{
public: 
     Dtk_pnt                  start_point; 
     Dtk_pnt                  end_point;
 
 
 
 
     Dtk_feat_translate_point ();
 
 
 
 
     ~Dtk_feat_translate_point (); 
 
 
 
 
     int  get_start_point ( Dtk_pnt *);
 
 
 
     int  get_end_point ( Dtk_pnt *);
 
};
 
 
class Dtk_feat_translate_coordinates 
{
public: 
     double                   X; 
     double                   Y; 
     double                   Z; 
 
     Dtk_transfo *       AxisSystem;  
 
 
 
     Dtk_feat_translate_coordinates();
 
 
 
 
     ~Dtk_feat_translate_coordinates (); 
 
 
 
 
     int  get_X ( double *);
 
 
 
 
 
     int  get_Y ( double *);
 
 
 
 
 
 
     int  get_Z ( double *);
 
 
 
 
     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;
 
 
 
     Dtk_feat_translate();
 
 
 
 
     ~Dtk_feat_translate (); 
 
 
 
 
     int  get_type ( TRANSLATE_TYPE *);
 
 
 
     int  get_direction_translate ( Dtk_feat_translate_direction **);
 
 
 
     int  get_point_to_point_translate ( Dtk_feat_translate_point  **);
 
 
 
 
     int  get_coordinates_translate ( Dtk_feat_translate_coordinates **);
 
 
 
     int  get_is_surface_translate( bool*);
 
 
 
     int  get_surface_translate( Dtk_feat_surface_transfo**);
};
 
 
class Dtk_feat_rotate_axis 
{
public: 
     Dtk_feat_axis       * axis; 
     double                   angle; 
 
 
 
     Dtk_feat_rotate_axis ();
 
 
 
     ~Dtk_feat_rotate_axis (); 
 
 
 
     int  get_axis ( Dtk_feat_axis **);
 
 
 
 
     int  get_angle ( double *);
 
 
};
 
 
 
class Dtk_feat_rotate_points 
{
public: 
     Dtk_pnt                  first_point; 
     Dtk_pnt                  second_point;
     Dtk_pnt                  third_point;
 
 
 
 
     Dtk_feat_rotate_points ();
 
 
 
 
     ~Dtk_feat_rotate_points (); 
 
 
 
 
     int  get_first_point ( Dtk_pnt *);
 
 
 
 
     int  get_second_point ( Dtk_pnt *);
 
 
 
     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; 
 
 
 
 
     Dtk_feat_rotate_axis_elements();
 
 
 
 
     ~Dtk_feat_rotate_axis_elements (); 
 
 
 
 
     int  get_axis ( Dtk_feat_axis **);
 
 
 
 
 
     int  get_first_element ( Dtk_feat_geometry **);
 
 
 
 
 
     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;
 
 
 
     Dtk_feat_rotate();
 
 
 
 
     ~Dtk_feat_rotate (); 
 
 
 
 
     int  get_type ( ROTATE_TYPE *);
 
 
 
 
     int  get_axis_angle_rotate ( Dtk_feat_rotate_axis **);
 
 
 
 
     int  get_three_points_rotate ( Dtk_feat_rotate_points **);
 
 
 
 
 
     int  get_axis_twoElements_rotate ( Dtk_feat_rotate_axis_elements **);
 
 
 
 
     int  get_is_surface_rotate ( bool*);
 
 
 
 
     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(); 
 
 
 
 
     int get_type        ( DTK_BOOLEAN_TYPE *);
 
 
 
 
     int get_combined_body         ( Dtk_FeaturePtr &);
 
 
 
 
     int get_main_body        ( Dtk_FeaturePtr &);
 
 
 
 
     int get_nb_combined_bodies         ( long*);
 
};
 
 
 
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 ();
 
 
 
 
 
     int get_propagation      ( PROPAGATION_TYPE *);
 
 
 
 
 
 
     int get_profiles_nb      ( int*);
 
 
 
     int get_profiles         ( Dtk_feat_geometry***);
 
 
};
 
 
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 ();
 
 
 
 
 
     int  get_direction       (Dtk_feat_axis **);
 
 
 
 
     int get_angle       ( double *);
 
 
 
 
     int get_neutral_element       ( Dtk_feat_draft_neutral_element **);
 
};
 
 
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 ();
 
 
 
 
     int  get_point ( Dtk_pnt*);
 
 
     int  get_angle ( double *);
 
 
     int  get_ratio ( double *);
 
 
 
 
     int  get_elt ( Dtk_feat_geometry **);
 
 
 
} ;
 
class Dtk_feat_parting_element {
 
public:
 
     Dtk_feat_geometry   * profile; 
     Bool                both_sides; 
     Bool                isEqualNeutral; 
 
     Dtk_feat_parting_element();
     ~Dtk_feat_parting_element ();
 
 
 
 
     int  get_profile ( Dtk_feat_geometry **);
 
 
 
     int  get_isEqualNeutral ( Bool *);
 
 
 
     int  get_both_sides ( Bool *);
 
} ;
 
 
 
class Dtk_feat_draft_constant {
 
public:
 
 
     SELECTION_MODE      selection;
     DRAFT_FORM               form; 
 
     Dtk_feat_draft_neutral_element      * neutral_element;
 
 
 
 
     Dtk_feat_draft_constant(); 
 
 
 
     ~Dtk_feat_draft_constant();
 
 
 
 
     int  get_form ( DRAFT_FORM *);  
 
 
 
 
     int  get_selection ( SELECTION_MODE *);
 
 
 
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
};
 
class Dtk_feat_draft_variable {
 
public:
 
 
     Dtk_feat_draft_neutral_element * neutral_element;
 
     Dtk_feat_draft_var_point ** var_points; 
     int                      var_points_nb; 
 
 
 
 
 
     Dtk_feat_draft_variable ();
 
 
 
     ~Dtk_feat_draft_variable (); 
 
 
 
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
 
 
 
 
     int  get_var_points ( Dtk_feat_draft_var_point ***);  
 
 
 
 
     int  get_var_points_nb ( int *);  
 
 
 
};
 
 
 
class Dtk_feat_draft_reflect_line {
 
public:
 
 
 
 
     Dtk_feat_draft_reflect_line(); 
 
 
 
     ~Dtk_feat_draft_reflect_line();
};
 
 
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;
 
 
 
 
 
 
     Dtk_feat_draft_advanced(); 
 
 
 
     ~Dtk_feat_draft_advanced();
 
 
 
 
 
     int  get_selection ( SELECTION_MODE *);
 
 
 
 
     int  get_driving_mode ( DRIVING_MODE *);
 
 
 
 
     int  get_driving_side  ( DRIVING_SIDE *);
 
 
 
     int  get_fitted_parameter ( double *);
 
 
 
 
     int  get_second_side ( Dtk_feat_draft_side **);
 
 
 
     int  get_neutral_element ( Dtk_feat_draft_neutral_element **);
 
};
 
 
 
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;
 
 
 
 
 
     Dtk_feat_draft ();
 
 
 
     ~Dtk_feat_draft (); 
 
 
 
 
 
     int  get_type ( DRAFT_TYPE *);
 
 
 
 
     int  get_default_angle ( double *);
 
 
 
 
     int  get_default_direction    (Dtk_feat_axis **);
 
 
 
 
     int  get_parting_element ( Dtk_feat_parting_element **);
 
 
 
 
     int  get_draft_faces ( Dtk_feat_geometry ** *); 
 
 
 
     int  get_draft_faces_nb ( int *);  
 
 
 
 
     int  get_limiting_elements ( Dtk_feat_geometry ***);  
 
 
 
 
     int  get_limiting_elements_nb ( int *);  
 
 
 
 
     int  get_constant_draft ( Dtk_feat_draft_constant **);
 
 
 
     int  get_variable_draft ( Dtk_feat_draft_variable **); 
 
 
 
     int  get_reflect_line_draft ( Dtk_feat_draft_reflect_line **);
 
 
 
     int  get_advanced_draft ( Dtk_feat_draft_advanced **); 
 
 
};
 
 
 
class Dtk_feat_stiffener {
 
public:
 
     Dtk_feat_geometry * profile; 
           
     double                   thick1; 
     double                   thick2; 
     Bool                isNeutralFiber; 
     Bool                isReverseThickness; 
     Bool                isReverseDepth; 
     STIFFENER_MODE      mode;
 
 
 
 
     Dtk_feat_stiffener ();
 
 
 
     ~Dtk_feat_stiffener (); 
 
 
 
 
 
     int get_profile (Dtk_feat_geometry **);
 
 
 
 
 
     int get_mode (STIFFENER_MODE *); 
 
 
 
 
     int get_thick1 (double *); 
 
 
 
 
     int get_thick2 (double *); 
 
 
 
 
     int get_isNeutralFiber (Bool *); 
 
 
 
 
     int get_isReverseThickness (Bool *); 
 
 
 
 
     int get_isReverseDepth(Bool *); 
 
}; 
 
 
 
 
class Dtk_feat_scaling {
 
public:
 
     Dtk_feat_geometry * reference; 
     double                   ratio;  
 
 
 
 
 
     Dtk_feat_scaling ();
 
 
 
     ~Dtk_feat_scaling (); 
 
 
 
 
 
     int get_reference (Dtk_feat_geometry **);
 
 
 
 
     int get_ratio (double *);
 
 
}; 
 
 
class Dtk_feat_loft_section {
 
public:
 
 
 
     Dtk_feat_geometry*       sectionCurve; 
     Dtk_feat_geometry*       closingPoint; 
 
     /* tangent ???  */
 
 
     Dtk_feat_loft_section();
     ~Dtk_feat_loft_section ();
 
 
 
     int get_section_curve (Dtk_feat_geometry**);
 
 
 
     int get_closing_point (Dtk_feat_geometry**);
 
 
};
 
class Dtk_feat_loft_guide {
 
public:
 
 
 
     Dtk_feat_geometry*       guideCurve; 
     int                           guideDimension; 
 
 
     Dtk_feat_loft_guide();
     ~Dtk_feat_loft_guide ();
 
 
 
     int get_guide_curve (Dtk_feat_geometry**);
 
 
 
     int get_guide_dimension (int*);
 
};
 
 
 
 
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();
 
 
 
 
 
     int get_type (COUPLING_TYPE *);
 
 
 
 
     int  get_coupling_points (Dtk_tab<Dtk_feat_geometry*> &); 
 
 
 
     int  get_coupling_points_nb ( int *); 
 
 
 
     int get_coupling_display  (Bool *);
 
};
 
 
 
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; 
 
 
 
     Dtk_feat_loft();
 
 
 
     ~Dtk_feat_loft();
 
 
 
 
 
 
     int get_type                  (DTK_LOFT_TYPE *);
 
 
 
 
     int  get_sections (Dtk_tab <Dtk_feat_loft_section*> &); 
 
 
 
 
     int  get_sections_nb ( int *);  
 
 
 
     int  get_guides (Dtk_tab <Dtk_feat_loft_guide*> &); 
 
 
 
 
     int  get_guides_nb ( int *);  
 
 
 
 
     int  get_coupling ( Dtk_feat_loft_coupling **); 
 
 
 
 
     int  get_spine ( Dtk_feat_geometry **); 
 
 
 
 
     int  get_isComputedSpine ( Bool *); 
 
 
 
     int  get_relimited_start_section ( Bool *); 
 
 
 
     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;*/
 
 
 
 
     Dtk_feat_thickness_feat ();
 
 
 
     ~Dtk_feat_thickness_feat ();
 
 
 
 
     int get_default_thickness (double *);
 
 
 
     int get_nb_default_faces ( int *);
 
 
 
 
     int get_default_faces ( Dtk_tab<Dtk_feat_geometry*> &); 
 
 
 
 
     int get_nb_skins ( int *);
 
 
 
 
     int get_skins ( Dtk_tab <Dtk_feat_thickness_face*> & );
 
 
};
 
 
 
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();
 
 
 
 
 
     int  get_first_limit               (Dtk_feat_limit **);
 
 
 
 
     int  get_second_limit              (Dtk_feat_limit **);
 
 
 
 
 
 
     int  get_profile    (Dtk_feat_geometry **);
 
};
 
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 :
 
 
 
 
     Dtk_feat_multi_prism ();
 
 
 
     ~Dtk_feat_multi_prism ();
 
 
 
     int get_type                  (DTK_PRISM_TYPE *);
 
 
 
 
     int  get_profiles             (Dtk_feat_geometry **);
 
 
 
 
     int  get_direction  (Dtk_feat_axis **);
 
 
 
 
     int  get_normal_to_surface    (Bool*);
 
 
 
 
 
     int  get_prism_domains   (Dtk_tab <Dtk_feat_prism_domain*> &);
 
 
 
 
     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;          
 
 
 
 
 
 
     Dtk_feat_body();
 
 
 
 
 
     ~Dtk_feat_body();
 
 
 
 
 
     int get_inner_feat_nb (long *);
 
 
 
 
 
     int get_inner_feat_tab (Dtk_tab<Dtk_FeaturePtr> &);
 
 
 
 
 
     int get_visibility  (Bool *);
 
 
 
 
 
 
     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;      
     }
 
     int get_value_type (DTK_USER_DEFINED_VAL_TYPE & outType); 
 
     int get_value_role (Dtk_string & outRole); 
 
     int get_value_double (double & outValue); 
 
     int get_value_integer (int & outValue); 
 
     int get_value_string (Dtk_string & outValue); 
 
     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 ();
 
 
     int get_type  (Dtk_string & outType);
 
 
 
     int get_name  (Dtk_string & outName);
 
 
 
     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... 
     }*/
 
 
 
 
 
     Dtk_feat_surf_feature ();
 
 
 
 
     ~Dtk_feat_surf_feature();
 
 
 
 
     int get_surf_feat_type (DTK_SURF_FEATURE_TYPE *);
 
 
 
     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;*/
 
 
 
 
 
 
     Dtk_feat_sheet_metal ();
 
 
 
     ~Dtk_feat_sheet_metal();
 
 
 
 
 
     int get_shm_feat_type (DTK_SHM_FEATURE_TYPE *);
 
 
 
 
 
     int get_shm_module_type (DTK_SHM_MODULE_TYPE *);
 
 
 
 
 
 
     int get_unFold_output_geometry (Dtk_feat_geometry **);
 
 
};
 
 
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(); 
 
 
 
 
     DtkErrorStatus get_start_point     ( Dtk_pnt & startPointOut) const;
 
 
     DtkErrorStatus get_end_point  ( Dtk_pnt & endPointOut) const;
 
 
     DtkErrorStatus get_center_point    ( Dtk_pnt & centerPointOut) const;
 
 
     DtkErrorStatus get_spline_curve    ( Dtk_CurvePtr& splineCurveOut) const;
 
 
    DtkErrorStatus get_section_set_point (SECTION_SET_POINT& outSectionSetPoint) const;
 
    DtkErrorStatus get_TurnRadius ( double & outTurnRadius) const;
 
    DtkErrorStatus get_OrientationPlane ( Dtk_PlaneSurfacePtr & outOrientationPlane) const;
 
}; 
 
 
class Dtk_Pipe_Section {
 
public:   
     Dtk_tab <Dtk_CurvePtr>                  profileSet;
     //Dtk_tab <Dtk_CurvePtr>                fiberSet; 
 
 
 
     Dtk_Pipe_Section ();
 
 
 
     ~Dtk_Pipe_Section ();
 
 
 
     Dtk_ErrorStatus get_profile_set (Dtk_tab <Dtk_CurvePtr> & outProfileSet) const;
 
 
 
     //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(); 
 
 
     Dtk_ErrorStatus get_type (DTK_PIPE_TYPE& outType) const;
 
 
 
     DtkErrorStatus get_start_point     ( Dtk_pnt & outStartPoint) const;
 
 
     DtkErrorStatus get_end_point  ( Dtk_pnt & outEndPoint) const;
 
 
 
 
     Dtk_ErrorStatus get_section_type (DTK_PIPE_SECTION_TYPE& outsectionType) const;
    
 
 
     DtkErrorStatus get_start_section ( Dtk_Pipe_Section* & outStartSection) const;
 
 
     DtkErrorStatus get_end_section     ( Dtk_Pipe_Section* & outEndSection) const;
 
 
 
     DtkErrorStatus get_is_closed  ( Dtk_bool & outIsClosed) const;
 
 
     DtkErrorStatus get_Height     ( double & outHeight) const;
 
 
     DtkErrorStatus get_Width ( double & outWidth) const;
 
     DtkErrorStatus get_Diameter   ( double & outDiameter) const;
 
 
     DtkErrorStatus get_CornerRadius    ( double & outCornerRadius) const;
     
     DtkErrorStatus get_NodeTable ( Dtk_tab <Dtk_pnt>& outNodeTable) const;
 
     Dtk_ErrorStatus get_neutral_fiber_set (Dtk_tab <Dtk_pipe_fiber_segment*> & outNeutralFiberSet) const;
};
 
 
 
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
     };
 
     Dtk_feat_SpotPoint();
 
     Dtk_feat_SpotPoint(const Dtk_feat_SpotPoint & spot);
 
     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
          );
 
 
     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
          );
 
     ~Dtk_feat_SpotPoint();
 
     Dtk_feat_SpotPoint & operator= (const Dtk_feat_SpotPoint & spot);
 
     Dtk_pnt location() const;
     void setLocation(const Dtk_pnt & p_location);
     void setLocation(double x, double y, double z);
 
     Dtk_dir normal() const;
     void setNormal(const Dtk_dir & p_normal);
     void setNormal(double x, double y, double z);
 
     double diameter() const;
     void setDiameter(double p_diam);
 
     bool isInspectionFlag() const;
     void setInspectionFlag(bool p_flag);
 
     bool isGeometryFlag() const;
     void setGeometryFlag(bool p_flag);
 
     ProcessCategory processCategory() const;
     void setProcessCategory(ProcessCategory p_category);
     void setProcessCategory(Dtk_string const & p_category);
 
     ProcessType processType() const;
     void setProcessType(ProcessType p_type);
     void setProcessType(Dtk_string const & p_type);
 
     Robustness robustness() const;
     void setRobustness(Robustness p_robustness);
     void setRobustness(Dtk_string const & p_robustness);
 
     Regulation regulation() const;
     void setRegulation(Regulation p_regulation);
     void setRegulation(Dtk_string const & p_regulation);
 
     Finish finish() const;
     void setFinish(Finish p_finish);
     void setFinish(Dtk_string const & p_finish);
 
     Material material() const;
     void setMaterial(Material p_material);
     void setMaterial(Dtk_string const & p_material);
 
     Dtk_string manufacturingCode() const;
     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;
 
};
 
 
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;
 
     Dtk_feat();
 
     Dtk_feat( const Dtk_feat&s );
 
     ~Dtk_feat();
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Entity::DtkDynamicType(inId); 
     }
 
     static Dtk_feat* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_feat*>(s); 
          return NULL; 
     } 
 
     type_detk get_type_detk() const { return DTK_TYPE_FEATURE; }
 
     static Dtk_FeaturePtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
     static Dtk_FeaturePtr release(Dtk_FeaturePtr inFeature);
 
 
     int get_type (DTK_FEATURE_TYPE *);
     DTK_FEATURE_TYPE GetType() const {return type;}
 
     Dtk_string GetTypeAsString();
     //int get_id (long *);
 
 
     int get_name (Dtk_string *);
     Dtk_string GetName() const {return name;}
 
 
     int GetId() const {return id;}
 
 
     int get_input_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetInputGeometry()const{return input_geometry;}
 
 
     int get_output_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetOutputGeometry()const{return output_geometry;}
 
 
     int get_associated_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetAssociatedGeometry()const{return associated_geometry;}
 
 
 
     int get_final_associated_geometry (Dtk_feat_geometry **);
     Dtk_feat_geometry *GetFinalAssociatedGeometry()const{return final_associated_geometry;}
 
 
 
     int get_isActive (bool *);
    Dtk_bool IsActive() const {return isActive;}
 
 
 
 
     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;}
 
 
 
     int get_thread                ( Dtk_feat_thread **e);
     Dtk_feat_thread *GetThread()const{return entity.thread;}
 
 
 
 
     int get_shell                 ( Dtk_feat_shell **e);
     Dtk_feat_shell *GetShell()const{return entity.shell;}
 
 
 
     int get_fillet                ( Dtk_feat_fillet **e);
     Dtk_feat_fillet *GetFillet()const{return entity.fillet;}
 
 
 
 
     int get_face_fillet                ( Dtk_feat_face_fillet **e);
     Dtk_feat_face_fillet *GetFaceFillet()const{return entity.face_fillet;}
 
 
 
 
     int get_tritangent_fillet          ( Dtk_feat_tritangent_fillet **e);
     Dtk_feat_tritangent_fillet *GetTriTangentFillet()const{return entity.tritangent_fillet;}
 
 
 
 
 
     int get_prism                 ( Dtk_feat_prism **e);
     Dtk_feat_prism *GetPrism()const{return entity.prism;}
 
 
 
 
 
     int get_multi_prism                ( Dtk_feat_multi_prism **e);
     Dtk_feat_multi_prism *GetMultiPrism()const{return entity.multi_prism;}
 
 
 
 
     int get_revol                 ( Dtk_feat_revol **e);
     Dtk_feat_revol *GetRevol()const{return entity.revol;}
 
 
 
     int get_sweep                 ( Dtk_feat_sweep **e);
     Dtk_feat_sweep *GetSweep()const{return entity.sweep;}
 
 
 
     int get_chamfer                    ( Dtk_feat_chamfer **e);
     Dtk_feat_chamfer *GetChamfer()const{return entity.chamfer;}
 
 
 
 
     int get_draft                 ( Dtk_feat_draft **e);
     Dtk_feat_draft *GetDraft()const{return entity.draft;}
 
 
 
 
     int get_mirror                ( Dtk_feat_mirror **e);
     Dtk_feat_mirror *GetMirror()const{return entity.mirror;}
 
 
 
 
     int get_pattern                    ( Dtk_feat_pattern **e);
     Dtk_feat_pattern *GetPattern()const{return entity.pattern;}
 
 
 
 
 
     int get_user_pattern     ( Dtk_feat_user_pattern **e);
     Dtk_feat_user_pattern *GetUserPattern()const{return entity.user_pattern;}
 
 
 
 
     int get_boolean_operation ( Dtk_feat_boolean **e);
     Dtk_feat_boolean *GetBooleanOperation()const{return entity.boolean_op;}
 
 
 
 
     int get_body ( Dtk_feat_body **e);
     Dtk_feat_body *GetFeatBody()const{return entity.body;}
 
 
 
 
     int get_split_surf ( Dtk_feat_split_surf **e);
     Dtk_feat_split_surf *GetSplitSurface()const{return entity.split;}
 
 
 
 
 
     int get_close_surf ( Dtk_feat_close_surf **e);
     Dtk_feat_close_surf *GetCloseSurface()const{return entity.close;}
 
 
 
 
     int get_sew_surf ( Dtk_feat_sew_surf **e);
     Dtk_feat_sew_surf *GetSewSurface()const{return entity.sew;}
 
 
 
 
     int get_remove_face ( Dtk_feat_remove_face **e);
     Dtk_feat_remove_face *GetRemoveFace()const{return entity.remove_face;}
 
 
 
 
     int get_replace_face ( Dtk_feat_replace_face **e);
     Dtk_feat_replace_face *GetReplaceFace()const{return entity.replace_face;}
 
 
 
 
 
     int get_translate ( Dtk_feat_translate **e);
     Dtk_feat_translate *GetTranslate()const{return entity.translate;}
 
 
 
 
     int get_rotate ( Dtk_feat_rotate **e);
     Dtk_feat_rotate *GetRotate()const{return entity.rotate;}
 
 
 
 
 
     int get_symmetry ( Dtk_feat_symmetry **e);
     Dtk_feat_symmetry *GetSymmetry()const{return entity.symmetry;}
 
 
 
 
 
     int get_stiffener ( Dtk_feat_stiffener **e);
     Dtk_feat_stiffener *GetStiffener()const{return entity.stiffener;}
 
 
 
 
 
     int get_scaling ( Dtk_feat_scaling **e);
     Dtk_feat_scaling *GetScaling()const{return entity.scaling;}
 
 
 
 
 
     int get_sheet_metal  ( Dtk_feat_sheet_metal **e);
     Dtk_feat_sheet_metal *GetSheetMetal()const{return entity.sheet_metal;}
 
 
 
 
     int get_surf_feature ( Dtk_feat_surf_feature **e);
     Dtk_feat_surf_feature *GetSurfaceFeature()const{return entity.surf_feature;}
 
 
 
 
 
     int get_loft  ( Dtk_feat_loft **e);
     Dtk_feat_loft *GetLoft()const{return entity.loft;}
 
 
 
 
     int get_thickness_feat  ( Dtk_feat_thickness_feat **e);
     Dtk_feat_thickness_feat *GetThicknessFeature()const{return entity.thickness_feat;}
 
 
 
     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;}
 
 
 
     int get_spot_point ( Dtk_feat_SpotPoint *&e);
     Dtk_feat_SpotPoint *GetSpotPoint()const{return entity.spot_point;}
 
};
 
 
 
 
 
/* End of generic feature */
 
class Dtk_feat_node {
 
public:
 
     NODE_TYPE           type; 
     long           id;
     Dtk_string          name;
     //Dtk_feat     *    feature; 
     Dtk_FeaturePtr feature;
     Bool           isTreated; 
 
 
 
 
 
 
     Dtk_feat_node();
 
 
 
 
 
     ~Dtk_feat_node();
 
 
 
 
 
     int get_type (NODE_TYPE *);
 
 
 
 
 
     int get_id (long *);
 
 
 
 
     int get_name (Dtk_string *);
 
 
 
 
     int get_feature (Dtk_FeaturePtr &);
 
 
 
 
     int get_isTreated (Bool*);
}; 
 
#endif