util_kinematics_dtk.hpp

Go to the documentation of this file.

#ifndef _UTIL_KINEMATICS_DTK_HPP_
#define _UTIL_KINEMATICS_DTK_HPP_
#ifdef WIN32
#pragma warning(disable:4786)
#pragma warning(disable:4800)
#endif
 
#include "def/define.h"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_status.hpp"
#include "util/BaseTypes/dtk_string.hpp"
#include "util/BaseTypes/dtk_transfo.hpp"
#include "util/dtk_maindoc.hpp"
#include "util/dtk_maindoc_ptr.hpp"
#include "util/error_dtk.hpp"
#include "util/util_stl_dtk.hpp"
#include "util/util_ent_dtk.hpp"
#include <cstdio>
 
void DumpTransfo(FILE * inFile, Dtk_transfo transfo);
 
class Dtk_Kinematic;
class Dtk_KinNamedValue;
class Dtk_KinConstraint;
class Dtk_KinMechanism;
class Dtk_KinParameter;
class Dtk_KinCommand;
class Dtk_KinJoint;
class Dtk_KinLaw;
class Dtk_KinSpeedAcceleration;
class Dtk_KinFixPart;
class Dtk_KinCurve;
class Dtk_KinProduct;
class Dtk_KinFormula;
 
typedef Dtk_SmartPtr<Dtk_Kinematic> Dtk_KinematicPtr;
typedef Dtk_SmartPtr<Dtk_KinNamedValue> Dtk_KinNamedValuePtr;
typedef Dtk_SmartPtr<Dtk_KinConstraint> Dtk_KinConstraintPtr;
typedef Dtk_SmartPtr<Dtk_KinMechanism> Dtk_KinMechanismPtr;
typedef Dtk_SmartPtr<Dtk_KinParameter> Dtk_KinParameterPtr;
typedef Dtk_SmartPtr<Dtk_KinCommand> Dtk_KinCommandPtr;
typedef Dtk_SmartPtr<Dtk_KinJoint> Dtk_KinJointPtr;
typedef Dtk_SmartPtr<Dtk_KinLaw> Dtk_KinLawPtr;
typedef Dtk_SmartPtr<Dtk_KinSpeedAcceleration> Dtk_KinSpeedAccelerationPtr;
typedef Dtk_SmartPtr<Dtk_KinFixPart> Dtk_KinFixPartPtr;
typedef Dtk_SmartPtr<Dtk_KinCurve> Dtk_KinCurvePtr;
typedef Dtk_SmartPtr<Dtk_KinProduct> Dtk_KinProductPtr;
typedef Dtk_SmartPtr<Dtk_KinFormula> Dtk_KinFormulaPtr;
 
#ifdef KINEMATICS_OLD_CONNECTORS
typedef Dtk_ConnectorPart Dtk_KinPart;
typedef Dtk_Connector Dtk_KinConnector;
typedef Dtk_ConnectorPartPtr Dtk_KinPartPtr;
typedef Dtk_ConnectorPtr Dtk_KinConnectorPtr;
typedef Dtk_tab<Dtk_ConnectorPtr> Dtk_KinConnectorTab;
typedef Dtk_tab<Dtk_ConnectorPartPtr> Dtk_KinPartTab;
 
//! \ingroup KinClasses
//! \brief Set the release of a part defined by it name of file
void Dtk_SetReleaseByPartFileName(Dtk_string & inFileName, int inRelease);
 
//! \ingroup KinClasses
//! \brief Returns connectors associated at a part defined by it name of file
Dtk_ConnectorTab Dtk_GetConnectorsByPartFileName(Dtk_string & inFileName);
 
//! \brief Test if a connector belong at the connector table
//! \param inConnector the connector to be tested
Dtk_bool hasConnector(Dtk_KinConnectorPtr inConnector);
 
//! \brief Test if a connector belong at the connector table
//! \param inConnector Connector to be tested
Dtk_bool hasConnector(Dtk_KinConnectorPtr inConnector);
 
Dtk_KinPartPtr searchPartByNumChild(int inNumChild);
//! \brief Returns the number of the product associated at this object
#else //KINEMATICS_OLD_CONNECTORS
typedef Dtk_Component Dtk_KinPart;
typedef Dtk_NodeConnector Dtk_KinConnector;
typedef Dtk_ComponentPtr Dtk_KinPartPtr;
typedef Dtk_NodeConnectorPtr Dtk_KinConnectorPtr;
typedef Dtk_tab<Dtk_NodeConnectorPtr> Dtk_KinConnectorTab;
typedef Dtk_tab<Dtk_ComponentPtr> Dtk_KinPartTab;
#endif //KINEMATICS_OLD_CONNECTORS
 
typedef Dtk_tab<Dtk_KinConstraintPtr> Dtk_KinConstraintTab;
typedef Dtk_tab<Dtk_KinMechanismPtr> Dtk_KinMechanismTab;
typedef Dtk_tab<Dtk_KinParameterPtr> Dtk_KinParameterTab;
typedef Dtk_tab<Dtk_KinCommandPtr> Dtk_KinCommandTab;
typedef Dtk_tab<Dtk_KinJointPtr> Dtk_KinJointTab ;
typedef Dtk_tab<Dtk_KinLawPtr> Dtk_KinLawTab;
typedef Dtk_tab<Dtk_KinSpeedAccelerationPtr> Dtk_KinSpeedAccelerationTab;
typedef Dtk_tab<Dtk_KinCurvePtr> Dtk_KinCurveTab;
typedef Dtk_tab<Dtk_KinProductPtr> Dtk_KinProductTab;
 
typedef Dtk_tab<Dtk_string> Dtk_StringTab;
typedef Dtk_tab<Dtk_pnt> Dtk_PointTab;
 
 
 
 
//! \defgroup KinClasses Kinematics Classes & Functions 
//! \brief .
 
//! \brief Enum for parameter father type
enum DTK_KINEMATIC_TYPE
{
    DTK_KIN_TYPE_UNKNOWN,
    DTK_KIN_TYPE_JOINT,
    DTK_KIN_TYPE_COMMAND,
    DTK_KIN_TYPE_MECHANISM,
    DTK_KIN_TYPE_LAW,
    DTK_KIN_TYPE_SPEED_ACCELERATION
};
 
//! \brief Enum for the joints type
enum JOINT_TYPE
{
    DTK_NOTHING = 0,
    DTK_PRISMATIC = 1,
    DTK_REVOLUTE = 2,
    DTK_RIGID = 10,
    DTK_SPHERICAL = 11,
    DTK_POINT_CURVE = 12,
    DTK_SLIDE_CURVE = 13,
    DTK_ROLL = 14,
    DTK_CYLINDRICAL = 15,
    DTK_UNIVERSAL_JOINT = 16,
    DTK_CV_JOINT = 17,
    DTK_GEAR = 18,
    DTK_RACK = 19,
    DTK_CABLE = 20,
    DTK_SCREW = 21,
    DTK_POINT_SURFACE = 22,
    DTK_PLANAR = 23
};
 
//! \brief Enum for the command type
enum COMMAND_TYPE
{
    KIN_CMD_NOTHING = 0,
    KIN_CMD_ANGLE = 1,
    KIN_CMD_LENGTH = 2,
    KIN_CMD_ANGLE_JOINT1 = 3,
    KIN_CMD_LENGTH_JOINT1 = 4,
    KIN_CMD_ANGLE_JOINT2 = 5,
    KIN_CMD_LENGTH_JOINT2 = 6
};
 
//! \ingroup KinClasses
//! \brief Return the kinematic object
Dtk_KinematicPtr Dtk_GetKinematics();
 
//! \ingroup KinClasses
//! \brief Write Dump file
Dtk_status Dtk_DumpKinematics(const Dtk_string &inFileName);
 
//! \ingroup KinClasses
//! \brief Delete the kinematic object
Dtk_status Dtk_DeleteKinematics();
 
//! \ingroup KinClasses
//! \brief Set the kinematic object
void Dtk_SetKinematics(Dtk_KinematicPtr inKinematic);
 
 
//! \ingroup KinClasses
//! \class Dtk_KinNamedValue
//! \brief Dtk_KinNamedValue represents a named value.
//!
//! A named value is associated at a parameter.
//! \SmartPtr{Dtk_KinNamedValuePtr}
class Dtk_KinNamedValue: public Dtk_Object
{
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_KIN_NAMED_VALUE
     };
 
     //! \brief Default constructor 
     Dtk_KinNamedValue();
     //! \brief Copy constructor
     //! \param att the Dtk_KinNamedValue to be copied
     Dtk_KinNamedValue(const Dtk_KinNamedValue& att);
 
     //! \brief Destructor
     ~Dtk_KinNamedValue();
 
     friend class Dtk_SmartPtr<Dtk_KinNamedValue>;
private:
     void _Init();
     void _Copy(const Dtk_KinNamedValue &kin);
     void _Reset();
 
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Object::DtkDynamicType(inId); 
     }
 
     //! \DtkDynamicCast
     static Dtk_KinNamedValue* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_KinNamedValue*>(s); 
          return NULL; 
     } 
 
     //! \return The type of the entity type - DTK_TYPE_KINEMATICS - 
     type_detk get_type_detk() const { return DTK_TYPE_KIN_NAMED_VALUE; }
 
     //! \CreateBase
     static Dtk_KinNamedValuePtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinNamedValuePtr release(Dtk_KinNamedValuePtr inNamedValue);
 
    //! \brief Write Dump file for named value
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinNamedValue attribut;
    //! attribut.setName(Dtk_string("sample named value"));
    //! attribut.setValue(5.21);
    //! attribut.Dump(file);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <namedValue name="sample named value" value="5.210000"/>
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Returns the name of the value
    Dtk_string getName();
    //! \brief Sets the name
    //! \param inName name
    void setName(Dtk_string inName);
    //! \brief Returns the value of the name
    double getValue();
    //! \brief Sets the value
    //! \param inValue Value
    void setValue(double inValue);
private:
protected:
    Dtk_string _name;
    double _valeur;
};
 
//! \ingroup KinClasses
//! \class Dtk_KinParameter
//! \brief Dtk_KinParameter represents a kinematic parameter
//!
//! A parameter references a named value.
//! \SmartPtr{Dtk_KinParameterPtr}
class Dtk_KinParameter : public Dtk_Object
{
    friend class Dtk_KinLaw;
    friend class Dtk_KinMechanism;
    friend class Dtk_KinCommand;
    friend class Dtk_KinJoint;
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_KIN_PARAMETER
     };
 
     //! \brief Default constructor 
     Dtk_KinParameter();
     //! \brief Copy constructor
     //! \param param the Dtk_KinParameter to be copied
     Dtk_KinParameter(const Dtk_KinParameter& param);
 
     //! \brief Destructor
     ~Dtk_KinParameter();
     friend class Dtk_SmartPtr<Dtk_KinParameter>;
private:
     void _Init();
     void _Copy(const Dtk_KinParameter &kin);
     void _Reset();
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Object::DtkDynamicType(inId); 
     }
 
     //! \DtkDynamicCast
     static Dtk_KinParameter* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_KinParameter*>(s); 
          return NULL; 
     } 
 
     //! \return The type of the entity type - DTK_TYPE_KIN_PARAMETER - 
     type_detk get_type_detk() const { return DTK_TYPE_KIN_PARAMETER; }
 
     //! \CreateBase
     static Dtk_KinParameterPtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //! \brief Name for optional attribute
    //static 
     Dtk_string _RANGE;
 
    //! \brief Delete object
    static Dtk_KinParameterPtr release(Dtk_KinParameterPtr inParameter);
 
    //! \brief Write Dump file for parameter
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinParameter parameter;
    //! parameter.setName(Dtk_string("sample parameter"));
    //! part.setId(1);
    //! parameter.Dump(file);
    //! \endcode
    //!
    //! \b Result simplified = false
    //! \code
    //! <parameter name="sample parameter" id="1">
    //!   <range nbValue="4" _1="..." _2="..." _3="..." _4="..." />
    //!   <!-- namedValue.Dump -->
    //! </parameter>
    //! \endcode
    //!
    //! \b Result simplified = true
    //! \code
    //! <parameter name="sample parameter" id="1" parent="%idParentNode_%typeNode">
    //! </parameter>
    //! // %typeNode = COMMAND or JOINT or MECHANISM or ...
    //! \endcode
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified=DTK_FALSE);
    //! \brief Test if 2 Dtk_KinParameter is equal
    //!
    //! Compare the id attributes.
    //! \param inParam Dtk_KinParameter to be tested
    Dtk_bool isEqual(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the parameter name
    Dtk_string getName();
    //! \brief Sets the parameter name
    //! \param inName parameter name
    void setName(Dtk_string inName);
    //! \brief Retrun the parameter id
    int getId();
    //! \brief Sets the parameter id
    //! \param inId parameter id
    void setId(int inId);
    //! \brief Returns the named value associated at the parameter
    Dtk_KinNamedValuePtr getNamedValue();
    //! \brief Sets the named value to be associated at parameter
    //! \param inAtt named value
    void setNamedValue(Dtk_KinNamedValuePtr inAtt);
 
    //! \brief Test if an attribute name belong at the attribute table
    //! \param inAtributeName Name of attribute
    //!
    //! The attribute table contains names of optional attribute used.
    //! The attribute name is defined with static variable.
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    //! \brief Add inAttribute at the attribute table
    //! \param inAttribute Attribute name to be added
    //!
    //! If the attribute table doesn't contain inAttribute,
    //! add inAttribute at the attribute table
    void addAttribute(Dtk_string inAttribute);
    //! \brief Returns Dtk_string at position inPosition.
    //! \param inPosition position of element
    //!
    //! If position is out bounds, returns Dtk_string()
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    //! \brief Return the attribute tab size
    Dtk_Size_t getAttributeSize();
 
    //! \brief Returns the node parent type of this parameter (joint, command or mechanism)
    DTK_KINEMATIC_TYPE getParentType();
    //! \brief Sets the type of the node parent
    //! \param inType Type o the node parent
    void setParentType(DTK_KINEMATIC_TYPE inType);
    //! \brief Returns the parent element
    //!
    //! \code
    //! Dtk_KinParameter * param = ...;
    //! if (param->getNodeParentType() == DTK_KIN_TYPE_JOINT)
    //! {
    //!     Dtk_KinJoint * joint = (Dtk_KinJoint *) param->getParentElement();
    //!     ...
    //! }
    //! \endcode
    void * getParentElement();
    //! \brief Sets the parent element
    //! \param inParent parent element
    void setParentElement(void * inParent);
 
    //! \brief Get the range value at position inPosition.
    //! \param inPosition Position
    double getRange(int inPosition);
    //! \brief Sets the range attribute of the parameter
    //! \param inRange the range table
    //!
    //! The RANGE name is added at attribute table.
    void setRange(double inRange[4]);
    //! \brief Sets the inValue of range attribute at inPosition
    //! \param inValue the value for range at position 
    //! \param inPosition position for the value
    //!
    //! The RANGE name is added at attribute table.
    void setRange(double inValue, int inPosition);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    Dtk_KinNamedValuePtr _namedValue;
 
    Dtk_StringTab _attributeList;
 
    DTK_KINEMATIC_TYPE _parentType;
    void * _parentNode;
 
    //! Optional attribute for KinTime parameter
    double _range[4];
};
 
//! \ingroup KinClasses
//! \class Dtk_KinProduct
//! \brief Dtk_KinProduct represents a kinematic product
//! \SmartPtr{Dtk_KinProductPtr}
class Dtk_KinProduct: public Dtk_Object
{
 
protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_PRODUCT
          };
 
          //! \brief Default constructor 
          Dtk_KinProduct();
          //! \brief Copy constructor
          //! \param part the Dtk_KinPart to be copied
          Dtk_KinProduct(const Dtk_KinProduct& inProd);
 
          //! \brief Destructor
          ~Dtk_KinProduct();
          friend class Dtk_SmartPtr<Dtk_KinProduct>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinProduct &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinProduct* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinProduct*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_PRODUCT - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_PRODUCT; }
 
          //! \CreateBase
          static Dtk_KinProductPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Write Dump file for product
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinProduct product;
    //! product.setName(Dtk_string("sample product"));
    //! product.setId(1);
    //! product.Dump(file);
    //! \endcode
    //!
    //! \code
    //! <product name="sample product" id="1" instanceName="...">
    //!   <components>
    //!     <!-- Products associated at this product -->
    //!     <!-- product.Dump(inFile)  -->
    //!     <!-- Parts associated at this product -->
    //!     <!-- part.Dump(inFile, false)  -->
    //!   </components>
    //! </product>
    //! \endcode
    Dtk_status Dump(FILE * inFile, int & inNum);
 
    //     //! \brief Test if 2 Dtk_KinProduct is equal
    //     //!
    //     //! Compare the id attributes.
    //     //! \param inProduct Dtk_KinProduct to be tested
    //    Dtk_bool operator==(Dtk_KinProduct & inProduct);
    //     //! \brief Test if 2 Dtk_KinProduct is equal
    //     //!
    //     //! Compare the id attributes.
    //     //! \param inProduct Dtk_KinProduct to be tested
    //    Dtk_bool isEqual(Dtk_KinProduct * inProduct);
 
    //! \brief Accessor for the name attribute
    Dtk_string& name();
    //! \brief Accessor for the id attribute
    int& id();
    //! \brief Accessor for the numChild attribute
    int& numChild();
    //! \brief Accessor for the instance name attribute
    Dtk_string& instanceName();
    //! \ brief Accessor for the file name attribute
    Dtk_string& fileName();
 
    //! \brief Returns the number of part associated
    Dtk_Size_t getNbPart();
    //! \brief Adds the part
    void addPart(Dtk_KinPartPtr inPart);
    //! \brief Returns the part at position inPos
    Dtk_KinPartPtr getPart(Dtk_Size_t inPos);
    //! \brief Returns the part by it numChild attribute
    Dtk_Size_t getNbProduct();
    //! \brief Adds the product
    void addProduct(Dtk_KinProductPtr inProduct);
    //! \brief Returns the product at position inPos
    Dtk_KinProductPtr getProduct(Dtk_Size_t inPos);
    //! \brief Returns the product by it numChild attribute
    Dtk_KinProductPtr searchProductByNumChild(int inNumChild);
protected:
    Dtk_string _name;
    int _ID;
    int _numChild;
 
    Dtk_string _instanceName;
    Dtk_string _fileName;
 
    Dtk_KinPartTab _parts;
    Dtk_KinProductTab _products;
private:
};
 
 
 
//! \ingroup KinClasses
//! \class Dtk_KinConstraint
//! \brief Dtk_KinConstraint represents a constraint to define a joint
//!
//! Constraints types:
//!  - Coincidence
//!  - Offset
//!  - Fix (only for fix part of mechanism)
//!  - FixTogether (only with Rigid joint)
//!
//! A constraint is linked at a kinematic object and a joint object.  
//! \SmartPtr{Dtk_KinConstraintPtr}
class Dtk_KinConstraint : public Dtk_Object 
{
    friend class Dtk_KinJoint;
    friend class Dtk_Kinematic;
    friend class Dtk_KinFixPart;
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_CONSTRAINT
          };
 
          //! \brief Default constructor 
          Dtk_KinConstraint();
          //! \brief Copy constructor
          //! \param constraint the Dtk_KinConstraint to be copied
          Dtk_KinConstraint(const Dtk_KinConstraint& constraint);
 
          //! \brief Destructor
          ~Dtk_KinConstraint();
 
          friend class Dtk_SmartPtr<Dtk_KinConstraint>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinConstraint &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinConstraint* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinConstraint*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KINEMATICS - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_CONSTRAINT; }
 
          //! \CreateBase
          static Dtk_KinConstraintPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //! \brief Name for optional attribute
    //static 
     Dtk_string _MODE_INTEGER;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _VALUE;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _ORIENTATION;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _REFERENCE;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _POSITION;
 
    //! \brief Delete object
    static Dtk_KinConstraintPtr release(Dtk_KinConstraintPtr inPart);
 
    //! \brief Write Dump file for constraint
    //! \param inFile the output file
    //! \param simplified determine if you write a simplified file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinConstraint constraint;
    //! constraint.setName(Dtk_string("sample constraint"));
    //! constraint.setId(1);
    //! constraint.Dump(file, true);
    //! \endcode
    //!
    //! \b Result (simplified = true)
    //! \code
    //! <constraint name="sample constraint" id="1">
    //! </constraint>
    //! \endcode
    //!
    //! \b Result (simplified = false)<br>
    //! All attributes are represented. Some attributes could not appear into out file.
    //! \code
    //! <constraint name="sample constraint" id="1">
    //!   <attributConstraint modeInteger="" value="" orientation="" fixInSpace="">
    //!     <matricePosition nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!   </attributConstraint>
    //!   <parts>
    //!     <!-- Parts associated at constraint -->
    //!     <!-- part.Dump(inFile, true)  -->
    //!   </parts>
    //! </constraint>
    //! \endcode
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    //! \brief Test if 2 Dtk_KinConstraint is equal
    //!
    //! Compare the id attribute.
    //! \param inPart Dtk_KinConstraint to be tested
    Dtk_bool operator==(Dtk_KinConstraint & inConstraint);
    //! \brief Test if 2 Dtk_KinConstraint is equal
    //!
    //! Compare the id attribute.
    //! \param inPart Dtk_KinConstraint to be tested
    Dtk_bool isEqual(Dtk_KinConstraintPtr inConstraint);
 
    //! \brief Returns the constraint name
    Dtk_string getName();
    //! \brief Sets the constraint name
    //! \param inName constraint name
    void setName(Dtk_string inName);
    //! \brief Retrun the constraint id
    int getId();
    //! \brief Sets the constraint id
    //! \param inId constraint id
    void setId(int inId);
 
  
    //! \brief Add a connector at the connector table
    //! \param inConnector the connector to be added
    //!
    //! The connector is added if connector table doesn't contain this connector
    void addConnector(Dtk_KinConnectorPtr inConnector);
    //! \brief Returns the connector at inPosition
    //! \param inPosition position of the connector
    //!
    //! If position is out bounds, returns NULL.
    Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition);
    //! \brief Return the attribute tab size
    Dtk_Size_t getConnectorSize();
    //! \brief Replace the connector at position inPosition by the connector inConnector
    void replaceConnector(Dtk_Size_t inPosition, Dtk_KinConnectorPtr inConnector);
 
    //! \brief Test if an attribute name belong at the attribute table
    //! \param inAtributeName Name of attribute
    //!
    //! The attribute table contains names of optional attribute used.
    //! The attribute name is defined with static variable.
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    //! \brief Add inAttribute at the attribute table
    //! \param inAttribute Attribute name to be added
    //!
    //! If the attribute table doesn't contain inAttribute, 
    //! add inAttribute at the attribut table
    void addAttribute(Dtk_string inAttribute);
    //! \brief Returns Dtk_string at position inPosition.
    //! \param inPosition position of element
    //!
    //! If position is out bounds, Returns Dtk_string()
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    //! \brief Return the attribute tab size
    Dtk_Size_t getAttributeSize();
 
    //! \brief Returns the Dtk_KinParameter represents the constraint value
    Dtk_KinParameterPtr getValue();
    //! \brief Sets the parameter for value
    //! \param inParam value
    //!
    //! The VALUE name is added at attribute table.
    void setValue(Dtk_KinParameterPtr inParam);
    //! \brief Returns the Dtk_KinParameter represents the orientation
    Dtk_KinParameterPtr getOrientation();
    //! \brief Sets the parameter for orientation
    //! \param inParam orientation
    //!
    //! The ORIENTATION name is added at attribute table.
    void setOrientation(Dtk_KinParameterPtr inParam);
    //! \brief Returns the Dtk_KinParameter represents the mode integer
    int getModeInteger();
    //! \brief Sets the parameter for mode integer
    //! \param inMode mode integer
    //!
    //! The MODE_INTEGER name is added at attribute table.
    void setModeInteger(int inMode);
    //! \brief Returns the Dtk_KinParameter represents the reference
    Dtk_KinParameterPtr getReference();
    //! \brief Sets the parameter for reference attribute
    //! \param inParam reference attribute
    //!
    //! The REFERENCE name is added at attribute table
    void setReference(Dtk_KinParameterPtr inParam);
    //! \brief Returns the part position
    Dtk_transfo getPosition();
    //! \brief Sets the part position 
    //! \param transfo Postion of the part
    //!
    //! The POSITION name is added at attribute table
    void setPosition(Dtk_transfo transfo);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    Dtk_KinConnectorTab _connectors;
 
    //! \brief Contains the names of the defining optional attributes forced.
    Dtk_StringTab _attributeTable;
 
    //! \brief Optional attribute (offset constraint)
    Dtk_KinParameterPtr _value;
    //! \brief Optional attribute (offset constraint)
    //!
    //!  - 1: same orientation
    //!  - 2: opposite orientation
    //!  - 3: undefined orientation
    Dtk_KinParameterPtr _orientation;
    //! \brief Optional attribute (offset constraint)
    //!
    //!  - 1: case reference not checked
    //!  - 2: case reference checked
    int _modeInteger;
    //! \brief Optional attribute (fix constraint)
    //!
    //!  - 1: case fix in space checked
    //!  - 2: case fix in space not checked
    Dtk_KinParameterPtr _reference;
    //! \brief Optional attribute (fix constraint)
    Dtk_transfo _position;
};
 
 
//! \ingroup KinClasses
//! \class Dtk_KinJoint
//! \brief Dtk_KinJoint represents a joint to define a mechanism.
//!
//! Joints types: 
//!  - prismatic
//!  - revolute
//!  - rigid
//!  - spherical
//!  - point curve
//!  - slide curve
//!  - roll
//!  - cylindrical
//!  - universal joint
//!  - CV joint
//!  - gear
//!  - rack
//!  - cable
//!  - screw
//!  - point surface
//!  - planar
//!
//! A joint is linked at a kinematic object, a mechanism object and a command object.
//! \SmartPtr{Dtk_KinJointPtr}
class Dtk_KinJoint  : public Dtk_Object
{
    friend class Dtk_KinCommand;
    friend class Dtk_Kinematic;
    friend class Dtk_KinMechanism;
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_JOINT
          };
 
          //! \brief Default constructor 
          Dtk_KinJoint();
          //! \brief Copy constructor
          //! \param joint the Dtk_KinJoint to be copied
          Dtk_KinJoint(const Dtk_KinJoint& joint);
 
          //! \brief Destructor
          ~Dtk_KinJoint();
          friend class Dtk_SmartPtr<Dtk_KinJoint>;
 
 
     private:
          void _Init();
          void _Copy(const Dtk_KinJoint &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinJoint* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinJoint*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_JOINT - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_JOINT; }
          //! \CreateBase
          static Dtk_KinJointPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //! \brief Name for optional attribute
    //static
     Dtk_string _CONSTRAINT;
    //! \brief Name for optional attribute
    //static
     Dtk_string _PARAMETER1;
    //! \brief Name for optional attribute
    //static
     Dtk_string _PARAMETER2;
    //! \brief Name for optional attribute
    //static
     Dtk_string _FIX_TOGETHER;
    //! \brief Name for optional attribute
    //static
     Dtk_string _ABSOLUT_POS1;
    //! \brief Name for optional attribute
    //static
     Dtk_string _ABSOLUT_POS2;
    //! \brief Name for optional attribute
    //static
     Dtk_string _UPPER_LIMIT1;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _LOWER_LIMIT1;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _UPPER_LIMIT2;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _LOWER_LIMIT2;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _PART3;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _LOCAL_FRAME3;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _LOCAL_FRAME4;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _JOINT1;
    //! \brief Name for optional attribute
    //static
     Dtk_string _JOINT2;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _RATIO;
    //! \brief Name for optional attribute
    //static 
     Dtk_string _RATIO_PARAMETER;
    //! \brief Name for optional attribute
    //static
     Dtk_string _CONNECTOR;
 
 
    //! \brief Delete object
    static Dtk_KinJointPtr release(Dtk_KinJointPtr inJoint);
 
    //! \brief Write Dump file for joint
    //! \param inFile the output file
    //! \param simplified determine if you write a simplified file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinJoint joint;
    //! joint.setName(Dtk_string("sample joint"));
    //! joint.setId(1);
    //! joint.Dump(file, true);
    //! \endcode
    //!
    //! \b Result (simplified = true)
    //! \code
    //! <joint name="sample joint" id="1">
    //! </joint>
    //! \endcode
    //!
    //! \b Result (simplified = false)<br>
    //! All attributes are represented. Some attributes could not appear into out file.
    //! \code
    //! <joint name="sample joint" id="1">
    //!   <attributJoint type="" compoundType="" parameter1="" parameter2="" ratio="">
    //!     <limit upperLimit1="" lowerLimit1="" upperLimit2="" lowerLimit2=""/>
    //!     <localFrame1 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!     <localFrame2 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!     <localFrame3 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!     <localFrame4 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!     <absolutePos1 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!     <absolutePos2 nbValue="12" _1="" _2="" _3="" _4="" _5="" _6="" _7="" _8="" _9="" _10="" _11="" _12="" /> 
    //!   </attributJoint>
    //!   <parts>
    //!     <!-- Parts associated at constraint -->
    //!     <!-- part.Dump(inFile, true)  -->
    //!   </parts>
    //!   <constraints>
    //!     <!-- Constraints associated at joint -->
    //!     <!-- constraint.Dump(inFile, true)  -->
    //!   </constraints>
    //!   <connector>
    //!     <!-- Connectors associated at joint -->
    //!     <!-- connector.Dump(inFile, true) -->
    //!   </connectors>
    //!   <!-- parameter.Dump(inFile) -->
    //!   <joints>
    //!     <!-- Joints associated at joint -->
    //!     <!-- joint.Dump(inFile, true)  -->
    //!   </joints>
    //! </joint>
    //! \endcode
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    //! \brief Test if 2 Dtk_KinJoint is equal
    //!
    //! Compare the id attributes.
    //! \param inPart Dtk_KinJoint to be tested
    Dtk_bool operator==(Dtk_KinJoint & inJoint);
    //! \brief Test if 2 Dtk_KinJoint is equal
    //!
    //! Compare the id attributes.
    //! \param inPart Dtk_KinJoint to be tested
    Dtk_bool isEqual(Dtk_KinJointPtr inJoint);
 
    //! \brief Returns the joint name
    Dtk_string getName();
    //! \brief Sets the joint name
    //! \param inName joint name
    void setName(Dtk_string inName);
    //! \brief Retrun the joint id
    int getId();
    //! \brief Sets the joint id
    //! \param inId joint id
    void setId(int inId);
    //! \brief Returns the joint type
    JOINT_TYPE getType();
    //! \brief Sets the type of the joint
    //! \param inType type of the joint
    void setType(int inType);
    //! \brief Returns the first part associated at the joint
    Dtk_KinPartPtr getPart1();
    //! \brief Sets the first part associated at the joint
    //! \param inPart Part to be associated at the joint
    void setPart1(Dtk_KinPartPtr inPart);
    //! \brief Returns the second part associated at the joint
    Dtk_KinPartPtr getPart2();
    //! \brief Sets the second part associated at the joint
    //! \param inPart Part to be associated at the joint
    void setPart2(Dtk_KinPartPtr inPart);
    //! \brief Returns the local frame 1 value
    Dtk_transfo getLocalFrame1();
    //! \brief Sets the local frame 1
    //! \param inTransfo Local frame to be set
    void setLocalFrame1(Dtk_transfo inTransfo);
    //! \brief Returns the local frame 2 value
    Dtk_transfo getLocalFrame2();
    //! \brief Sets the local frame 2
    //! \param inTransfo Local frame to be set
    void setLocalFrame2(Dtk_transfo inTransfo);
    //! \brief Returns the compound type attribute
    int getCompoundType();
    //! \brief Sets the compound type
    //! \param inCompoundType compound type
    void setCompoundType(int inCompoundtype);
 
    //! \brief Test if an attribute name belong at the attribute table
    //! \param inAtributeName Name of attribute
    //!
    //! The attribute table contains names of optional attribute used.
    //! The attribute name is defined with static variable.
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    //! \brief Add inAttribute at the attribute table
    //! \param inAttribute Attribute name to be added
    //!
    //! If the attribute table doesn't contain inAttribute,
    //! add inAttribute at the attribute table
    void addAttribute(Dtk_string inAttribute);
    //! \brief Returns Dtk_string at position inPosition.
    //! \param inPosition position of element
    //!
    //! If position is out bounds, returns Dtk_string()
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    //! \brief Return the attribute tab size
    Dtk_Size_t getAttributeSize();
 
    //! \brief Test if a constraint belong at the constraint table
    //! \param inConstraint Constraint to be tested
    Dtk_bool hasConstraint(Dtk_KinConstraintPtr inConstraint);
    //! \brief Returns Constraint at position inPosition
    //! \param inPosition position of element
    //!
    //! If the position is out bounds of constraint table, returns NULL
    Dtk_KinConstraintPtr getConstraint(Dtk_Size_t inPosition);
    //! \brief Add constraint at the constraint table
    //! \param inConstraint constraint to be added
    //!
    //! If the constraint table doesn't contain inConstraint, 
    //! the constraint added
    //!
    //! The CONSTRAINT name is added at attribute table.
    void addConstraint(Dtk_KinConstraintPtr inConstraint);
    //! \brief Return the attribute tab size
    Dtk_Size_t getConstraintSize();
    //! \brief Returns Connector at position inPosition
    //! \param inPosition position of element
    //!
    //! If the position is out bounds of connector table, returns NULL
    Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition);
    //! \brief Add connector at the connector table
    //! \param inConnector connector to be added
    //!
    //! If the connector table doesn't contain inConnector, 
    //! the connector added
    //!
    //! The CONNECTOR name is added at attribute table.
    void addConnector(Dtk_KinConnectorPtr inConnector);
    //! \brief Return the attribute tab size
    Dtk_Size_t getConnectorSize();
    //! \brief Return the connector tab
    Dtk_KinConnectorTab getConnectorTab();
    //! \brief Returns the first parameter
    double getParameter1();
    //! \brief Sets the first parameter of the joint
    //! \param inParam parameter 1 of the joint
    //!
    //! The PARAMETER1 name is added at attribute table.
    void setParameter1(double inParam);
    //! \brief Returns the second parameter
    double getParameter2();
    //! \brief Sets the second parameter of the joint
    //! \param inParam parameter 2 of the joint
    //!
    //! The PARAMETER2 name is added at attribute table.
    void setParameter2(double inParam);
    //! \brief Returns the fix together constraint
    Dtk_KinConstraintPtr getFixTogether();
    //! \brief Sets the fix together constraint of the joint
    //! \param inFix FixTogether constraint to be added
    //!
    //! The FIX_TOGETHER name is added at attribute table
    void setFixTogether(Dtk_KinConstraintPtr inFix);
    //! \brief Returns the part 1 absolute position
    Dtk_transfo getAbsolutPos1();
    //! \brief Sets the absolute position for part 1
    //! \param inTransfo Absolute position to be set
    //!
    //! The ABSOLUT_POS1 name is added at attribute table.
    void setAbsolutPos1(Dtk_transfo inTransfo);
    //! \brief Returns the part 2 absolute position 
    Dtk_transfo getAbsolutPos2();
    //! \brief Sets the absolute position for part 2
    //! \param inTransfo Absolute position to be set
    //!
    //! The ABSOLUT_POS2 name is added at attribute table
    void setAbsolutPos2(Dtk_transfo inTransfo);
    //! \brief Returns the upper limit 1
    double getUpperLimit1();
    //! \brief Sets the upper limit for the first parameter of joint
    //! \param inVal Value for the upper limit 1
    //!
    //! The UPPER_LIMIT1 name is added at attribute table.
    void setUpperLimit1(double inVal);
    //! \brief Returns the lower limit 1
    double getLowerLimit1();
    //! \brief Sets the lower limit for the first parameter of joint
    //! \param inVal Value for the lower limit 1
    //!
    //! The LOWER_LIMIT1 name is added at attribute table.
    void setLowerLimit1(double inVal);
    //! \brief Returns the upper limit 2
    double getUpperLimit2();
    //! \brief Sets the upper limit for the second parameter of joint
    //! \param inVal Value for the upper limit 2
    //!
    //! The UPPER_LIMIT2 name is added at attribute table.
    void setUpperLimit2(double inVal);
    //! \brief Returns the lower limit 2
    double getLowerLimit2();
    //! \brief Sets the lower limit for the second parameter of joint
    //! \param inVal Value for the lower limit 2
    //!
    //! The LOWER_LIMIT2 name is added at attribute table.
    void setLowerLimit2(double inVal);
    //! \brief Returns the third part associated at the joint
    Dtk_KinPartPtr getPart3();
    //! \brief Sets the third part associated at the joint
    //! \param inPart Part to be associated at the joint
    //!
    //! The PART3 name is added at attribute table.
    void setPart3(Dtk_KinPartPtr inPart);
    //! \brief Returns the local frame 3 value
    Dtk_transfo getLocalFrame3();
    //! \brief Sets the local frame 3
    //! \param inTransfo Local frame to be set
    void setLocalFrame3(Dtk_transfo inTransfo);
    //! \brief Returns the local frame 4 value
    Dtk_transfo getLocalFrame4();
    //! \brief Sets the local frame 4
    //! \param inTransfo Local frame to be set
    void setLocalFrame4(Dtk_transfo inTransfo);
    //! \brief Returns the first joint associated at the joint
    Dtk_KinJointPtr getJoint1();
    //! \brief Sets the first joint associated at the joint
    //! \param inJoint Joint to be associated at the joint
    //!
    //! The JOINT1 name is added at attribute table.
    void setJoint1(Dtk_KinJointPtr inJoint);
    //! \brief Returns the second joint associated at the joint
    Dtk_KinJointPtr getJoint2();
    //! \brief Sets the second joint associated at the joint
    //! \param inJoint Joint to be associated at the joint
    //!
    //! The JOINT2 name is added at attribute table
    void setJoint2(Dtk_KinJointPtr inJoint);
    //! \brief Returns the joint ratio value
    double getRatio();
    //! \brief Sets the ratio value of the joint
    //! \param inVal Value of the joint ratio
    //!
    //! The RATIO name is added at attribute table
    void setRatio(double inVal);
    //! \brief Returns the Dtk_KinParameter ratio of the joint
    Dtk_KinParameterPtr getRatioParameter();
    //! \brief Sets the joint Dtk_KinParameter ratio 
    //! \param inParam Ratio parameter
    //!
    //! The RATIO_PARAMETER name is added at attribute table
    void setRatioParameter(Dtk_KinParameterPtr inParam);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    //! Joint type:
    //!  - 1:  prismatic
    //!  - 2:  revolute
    //!  - 10: rigid
    //!  - 11: spherical
    //!  - 12: point curve
    //!  - 13: slide curve
    //!  - 14: roll
    //!  - 15: cylindrical
    //!  - 16: universal joint
    //!  - 17: CV joint
    //!  - 18: gear
    //!  - 19: rack
    //!  - 20: cable
    //!  - 21: screw
    //!  - 22: point surface
    //!  - 23: planar
    JOINT_TYPE _type;
    //! \brief This part is defined at the kinematic part table.
    Dtk_KinPartPtr _part1;
    //! \brief This part is defined at the kinematic part table.
    Dtk_KinPartPtr _part2;
    Dtk_transfo _localframe1;
    Dtk_transfo _localframe2;
    //! Compound joint 
    //!  - 0: not compound
    //!  - 1: compound
    int _compoundType;
 
    //! \brief Contains the names of the defining optional attributes forced.
    Dtk_StringTab _attributeTable;
 
    //! \brief Optional attribute.
    //! All constraints are defined at the kinematic constraint table.
    Dtk_KinConstraintTab _constraints;
    //! \brief Optional attribute.
    //! All connectors are defined at the specific part.
    Dtk_KinConnectorTab _connectors;
    //! Optional attribute
    double _parameter1;
    //! Optional attribute
    double _parameter2;
    //! \brief Optional attribute only with rigid joint.
    //! This constaint is defined at the kinematic constraint table.
    Dtk_KinConstraintPtr _fixTogether;
    //! Optional attribute
    Dtk_transfo _absolutepos1;
    //! Optional attribute
    Dtk_transfo _absolutepos2;
    //! Optional attribute
    double _upperlimit1;
    //! Optional attribute
    double _lowerlimit1;
    //! Optional attribute
    double _upperlimit2;
    //! Optional attribute
    double _lowerlimit2;
    //! \brief Optional attribute only with compound joint.
    //! This part is defined at the kinematic part table.
    Dtk_KinPartPtr _part3;
    //! Optional attribute only with compound joint
    Dtk_transfo _localframe3;
    //! Optional attribute only with compound joint
    Dtk_transfo _localframe4;
    //! \brief Optional attribute only with compound joint.
    //! This joint est defined at the kinematic joint table.
    Dtk_KinJointPtr _joint1;
    //! \brief Optional attribute only with compound joint
    //! This joint est defined at the kinematic joint table.
    Dtk_KinJointPtr _joint2;
    //! Optional attribute
    double _ratio;
    //! Optional attribute
    Dtk_KinParameterPtr _ratioParm;
};
 
//! \ingroup KinClasses
//! \class Dtk_KinCommand 
//! \brief Dtk_KinCommand represents a command to simulate a mechanism.
//!
//! A command is linked at a kinematic object and a mechanism object.
//! \SmartPtr{Dtk_KinCommandPtr}
class Dtk_KinCommand : public Dtk_Object 
{
    friend class Dtk_Kinematic;
    friend class Dtk_KinMechanism;
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_COMMAND
          };
 
          //! \brief Default constructor
          Dtk_KinCommand();
          //! \brief Copy constructor
          //! \param cmd the Dtk_KinCommand to be copied
          Dtk_KinCommand(const Dtk_KinCommand& cmd);
 
          //! \brief Destructor
          ~Dtk_KinCommand();
 
          friend class Dtk_SmartPtr<Dtk_KinCommand>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinCommand &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinCommand* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinCommand*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_COMMAND - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_COMMAND; }
          //! \CreateBase
          static Dtk_KinCommandPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
public:
 
    //! \brief Delete object
    static Dtk_KinCommandPtr release(Dtk_KinCommandPtr inCommand);
 
    //! \brief Write Dump file for command
    //! \param inFile the output file
    //! \param simplified determine if you write a simplified file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinCommand command;
    //! command.setName(Dtk_string("sample command"));
    //! command.setId(1);
    //! command.Dump(file, true);
    //! \endcode
    //!
    //! \b Result (simplified = true)
    //! \code
    //! <command name="sample command" id="1">
    //! </command>
    //! \endcode
    //!
    //! \b Result (simplified = false)
    //! \code
    //! <command name="sample command" id="1">
    //!   <attributCommand type="" value="" /> 
    //!   <!-- Joint associated at command / _joint.Dump(inFile,true) -->
    //!   <!-- Parameter associated at command / _parameter.Dump(inFile) -->
    //! </command>
    //! \endcode
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    //! \brief Test if 2 Dtk_KinCommand are equal.
    //!
    //! Compare the id attribute.
    //! \param inCommand Dtk_KinCommand to be tested
    Dtk_bool operator==(Dtk_KinCommand & inCommand);
    //! \brief Test if 2 Dtk_KinCommand are equal.
    //!
    //! Compare the id attribute.
    //! \param inCommand Dtk_KinCommand to be tested
    Dtk_bool isEqual(Dtk_KinCommandPtr inCommand);
 
    //! \brief Returns the command name
    Dtk_string getName();
    //! \brief Sets the command name
    //! \param inName command name
    void setName(Dtk_string inName);
    //! \brief Returns the command id
    int getId();
    //! \brief Sets the command id
    //! \param inId command id
    void setId(int inId);
    //! \brief Returns the command type
    COMMAND_TYPE getType();
    //! \brief Sets the type of the command
    //! \param inType type of the command
    void setType(int inType);
    //! \brief Returns the value of the command for simulation
    double getValue();
    //! \brief Sets the command value
    //! \param inValue Command value
    void setValue(double inValue);
    //! \brief Returns the joint associated at command.
    Dtk_KinJointPtr getJoint();
    //! \brief Sets the joint associated at command
    //! \param inJoint Joint command
    void setJoint(Dtk_KinJointPtr inJoint);
    //! \brief Returns the parameter associated at command
    Dtk_KinParameterPtr getParameter();
    //! \brief Sets the parameter command
    //! \param inParam Parameter command
    void setParameter(Dtk_KinParameterPtr inParam);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    //     3 => gear:joint1
    //     4 => rack:joint1/cable:joint1
    //     5 => rack:joint2/gear:joint2
    //     6 => cable:joint2
    //! type command:
    //!  - 1: Angle (not compound joint type)
    //!  - 2: Length (not compound joint type)
    //!  - 3: Angle (compound joint : angle command type associated at the first joint of compound joint)
    //!  - 4: Length (compound joint : length command type associated at the first joint of compound joint)
    //!  - 5: Angle (compound joint : angle command type associated at the second joint of compound joint)
    //!  - 6; Length (compound joint : length command type associated at the second joint of compound joint)
    COMMAND_TYPE _type;
    double _value;
    //! \brief This joint belongs at the kinematic joint table.
    Dtk_KinJointPtr _joint;
    Dtk_KinParameterPtr _parameter;
};
 
 
//! \ingroup KinClasses
//! \class Dtk_KinFixPart 
//! \brief Dtk_KinFixPart represents the fixed part to simulate the mechanism.
//!
//! A fixed part is linked at a mechanism object.
//! \SmartPtr{Dtk_KinFixPartPtr}
class Dtk_KinFixPart: public Dtk_Object
{
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_FIXPART
          };
 
          //! \brief Default constructor 
          Dtk_KinFixPart();
          //! \brief Copy constructor
          //! \param fixPart the Dtk_KinFixPart to be copied
          Dtk_KinFixPart(const Dtk_KinFixPart & fixPart);
 
          //! \brief Destructor
          ~Dtk_KinFixPart();
          friend class Dtk_SmartPtr<Dtk_KinFixPart>;
     private:
          void _Init();
          void _Copy(const Dtk_KinFixPart &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinFixPart* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinFixPart*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_FIXPART - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_FIXPART; }
          //! \CreateBase
          static Dtk_KinFixPartPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinFixPartPtr release(Dtk_KinFixPartPtr inFixPart);
 
    //! \brief Write Dump file for fix part
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinFixPart fixPart;
    //! fixPart.setName(Dtk_string("sample fixPart"));
    //! fixPart.setId(1);
    //! fixPart.Dump(file, true);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <part name="sample fixPart" id="1">
    //!   <!-- Constraint associated at the fix part / constraint.Dump(inFile, true) -->
    //!   <!-- Part associated at the fix part / part.Dump(inFile, true) -->
    //! </part>
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Returns the fix part name
    Dtk_string getName();
    //! \brief Sets the fix part name
    //! \param inName fix part name
    void setName(Dtk_string inName);
    //! \brief Retrun the fix part id
    int getId();
    //! \brief Sets the fix part id
    //! \param inId fix part id
    void setId(int inId);
    //! \brief Returns the constraint associated to the fixed part
    Dtk_KinConstraintPtr getConstraint();
    //! \brief Sets the constraint associated to the fixed part
    //! \param inConstraint fix part constraint
    void setConstraint(Dtk_KinConstraintPtr inConstraint);
    //! \brief Returns the part fixed
    Dtk_KinPartPtr getPart();
    //! \brief Sets the part fixed
    //! \param inPart Part to be fixed
    void setPart(Dtk_KinPartPtr inPart);
private:
protected:
    Dtk_string _name;
    int _ID;
    //! \brief This constraint is defined into the kinematic constraint table.
    Dtk_KinConstraintPtr _fixcst;
    //! \brief This part is defined into the kinematic part table.
    Dtk_KinPartPtr _fixpart;
};
 
//! \ingroup KinClasses
//! \class Dtk_KinMechanism 
//! \brief Dtk_KinMechanism represents a kinematic mechanism
//!
//! A mechanism is linked at a kinematic object.
//! \SmartPtr{Dtk_KinMechanismPtr}
class Dtk_KinMechanism : public Dtk_Object
{
    friend class Dtk_Kinematic;
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_MECHANISM
          };
 
          //! \brief Default constructor 
          Dtk_KinMechanism();
          //! \brief Copy constructor
          //! \param mecha the Dtk_KinMechanism to be copied
          Dtk_KinMechanism(const Dtk_KinMechanism& mecha);
 
          //! \brief Destructor
          ~Dtk_KinMechanism();
          friend class Dtk_SmartPtr<Dtk_KinMechanism>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinMechanism &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinMechanism* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinMechanism*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_MECHANISM - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_MECHANISM; }
 
          //! \CreateBase
          static Dtk_KinMechanismPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
public:
 
    //! \brief Delete object
    static Dtk_KinMechanismPtr release(Dtk_KinMechanismPtr inMechanism);
 
    //! \brief Write Dump file for mechanism
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinMechanism mechanism;
    //! mechanism.setName(Dtk_string("sample mechanism"));
    //! mechanism.setId(1);
    //! mechanism.Dump(file);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <mechanism name="sample mechanism" id="1" version="">
    //!   <parts>
    //!     <!-- Parts associated at mechanism -->
    //!     <!-- part.Dump(inFile, true)  -->
    //!   </parts>
    //!   <commands>
    //!     <!-- Commands associated at mechanism -->
    //!     <!-- commands.Dump(inFile, true)  -->
    //!   </commands>
    //!   <!-- specfix.Dump(inFile) -->
    //!   <paramTime>
    //!     <!-- paramTime.Dump(inFile) -->
    //!   </paramTime>
    //!   <laws>
    //!     <!-- law.Dump(inFile) -->
    //!   </laws>
    //! </mechanism>
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Test if 2 Dtk_KinMechanism is equal
    //!
    //! Compare the id attributes.
    //! \param inMechanism Dtk_KinMechanism to be tested
    Dtk_bool operator==(Dtk_KinMechanism & inMechanism);
    //! \brief Test if 2 Dtk_KinMechanism is equal
    //!
    //! Compare the id attributes.
    //! \param inMechanism Dtk_KinMechanism to be tested
    Dtk_bool isEqual(Dtk_KinMechanismPtr inMechanism);
 
    //! \brief Returns the mechanism name
    Dtk_string getName();
    //! \brief Sets the mechanism name
    //! \param inName mechanism name
    void setName(Dtk_string inName);
    //! \brief Returns the mechanism id
    int getId();
    //! \brief Sets the mechanism id
    //! \param inId mechanism id
    void setId(int inId);
    //! \brief Returns the mechanism version
    Dtk_string getVersion();
    //! \brief Sets the mechanism version
    //! \param inVersion mechanism version
    void setVersion(Dtk_string inVersion);
    //! \brief Test if the joint belong at joint table
    //! \param inJoint joint to be tested
    Dtk_bool hasJoint(Dtk_KinJointPtr inJoint);
    //! \brief Add a joint at the joint table
    //! \param inJoint joint to be added
    void addJoint(Dtk_KinJointPtr inJoint);
    //! \brief Returns Dtk_KinJoint at position inPos.
    //! \param inPos position of element
    //!
    //! If position is out bounds, returns NULL
    Dtk_KinJointPtr getJoint(Dtk_Size_t inPos);
    //! \brief Return the attribute tab size
    Dtk_Size_t getJointSize();
    //! \brief Test if the command belong at command table
    //! \param inCmd command to be tested
    Dtk_bool hasCommand(Dtk_KinCommandPtr inCmd);
    //! \brief Add a command at the command table
    //! \param inCmd command to be added
    void addCommand(Dtk_KinCommandPtr inCmd);
    //! \brief Returns Dtk_KinCommand at position inPos.
    //! \param inPos position of element
    //!
    //! If position is out bounds, returns \code NULL \endcode
    Dtk_KinCommandPtr getCommand(Dtk_Size_t inPos);
    //! \brief Return the attribute tab size
    Dtk_Size_t getCommandSize();
    //! \brief Returns the fix part object
    Dtk_KinFixPartPtr getFixPart();
    //! \brief Sets the fix part
    //! \param inSpecfix fix part
    void setFixPart(Dtk_KinFixPartPtr inFixPart);
    //! \brief Returns the time parameter  
    Dtk_KinParameterPtr getParamTime();
    //! \brief Sets the time parameter
    //! \param inParam time parameter
    void setParamTime(Dtk_KinParameterPtr inParam);
    //! \brief Test if the law belong at law table
    //! \param inLaw law to be tested
    Dtk_bool hasLaw(Dtk_KinLawPtr inLaw);
    //! \brief Add inLaw at the law table
    //! \param inLaw law to be added
    //!
    //! If the law table doesn't contain inLaw, inLaw is added
    void addLaw(Dtk_KinLawPtr inLaw);
    //! \brief Returns Dtk_KinLaw at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds Returns NULL
    Dtk_KinLawPtr getLaw(Dtk_Size_t inPos);
    //! \brief Return the attribute tab size
    Dtk_Size_t getLawSize();
    void deleteLaw(Dtk_KinLawPtr inLaw);
 
    //! \brief Test if the speed/acceleration belong at speed/acceleration table
    //! \param inSpeed speed/acceleration to be tested
    Dtk_bool hasSpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
    //! \brief Add inSpeed at the speed/acceleration at the speed/acceleration table
    //! \param inSpeed speed/acceleration to be added
    void addSpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
    //! \brief Returns Dtk_KinSpeedAcceleration at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns NULL
    Dtk_KinSpeedAccelerationPtr getSpeedAcceleration(Dtk_Size_t inPos);
    //! \brief Return the attribute tab size
    Dtk_Size_t getSpeedAccelerationSize();
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    Dtk_string _version;
    //! \brief All joints are defined into the kinematic joint table.
    Dtk_KinJointTab _jointList;
    //! \brief All commands are defined into the kinematic command table.
    Dtk_KinCommandTab _cmdList;
    Dtk_KinFixPartPtr _fixPart;
    Dtk_KinParameterPtr _mechParamTime;
    Dtk_KinLawTab _laws;
    Dtk_KinSpeedAccelerationTab _speedAcc;
};
 
 
 
//! \ingroup KinClasses
//! \class Dtk_Kinematic
//! \brief Dtk_Kinematic represents a kinematic
//! \SmartPtr{Dtk_KinematicPtr}
class Dtk_Kinematic: public Dtk_Entity
{
 
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_KINEMATIC
     };
 
     //! \brief     Default constructor of a generic Kinematics                                                  
     //! \param [in/out]                                                      
     //! \param [out]                                                     
     //! \return    Allocated generic Kinematics                         
     //! \remark  
     Dtk_Kinematic();
 
 
     //! \brief Copy constructor
     //! \param mecha the Dtk_Kinematic to be copied
     Dtk_Kinematic(const Dtk_Kinematic& kinematics);
 
     //! \brief     Default destructor of a generic Kinematics 
     //! \param [in/out]                                                     
     //! \param [out]                                                      
     //! \return    Free generic Kinematics   
     ~Dtk_Kinematic();
     inline virtual Dtk_Object* Clone() { return new Dtk_Kinematic(*this); }
     friend class Dtk_SmartPtr<Dtk_Kinematic>;
 
private:
     void _Init();
     void _Copy(const Dtk_Kinematic &kin);
     void _Reset();
 
public:
 
     //! \DtkDynamicType
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Entity::DtkDynamicType(inId); 
     }
 
     //! \DtkDynamicCast
     static Dtk_Kinematic* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_Kinematic*>(s); 
          return NULL; 
     } 
 
     //! \return The type of the entity type - DTK_TYPE_KINEMATIC - 
     type_detk get_type_detk() const { return DTK_TYPE_KINEMATIC; }
 
     //! \CreateBase
     static Dtk_KinematicPtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
    //! \brief Delete object
    static Dtk_KinematicPtr release(Dtk_KinematicPtr inKinematic);
 
    //! \brief Write Dump file for kinematic
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_Kinematic kinematic;
    //! ...
    //! kinematic.Dump(file);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <kinematics name="sample kinematic" id="5_1">
    //!   <parts>
    //!     <!-- Parts associated at kinematic -->
    //!     <!-- part.Dump(inFile, false)  -->
    //!   </parts>
    //!   <constraints>
    //!     <!-- Constraints associated at kinematic -->
    //!     <!-- constraint.Dump(inFile, false)  -->
    //!   </constraints>
    //!   <joints>
    //!     <!-- Joints associated at kinematic -->
    //!     <!-- joint.Dump(inFile, false)  -->
    //!   </joints>
    //!   <commands>
    //!     <!-- Commands associated at kinematic -->
    //!     <!-- command.Dump(inFile, false)  -->
    //!   </commands>
    //!   <mechanisms>
    //!     <!-- Mechanisms associated at kinematic -->
    //!     <!-- mechanism.Dump(inFile)  -->
    //!   </Mechanisms>
    //! </kinematics>
    //! \endcode
    Dtk_status Dump(FILE * inFile, Dtk_bool initXml = 1);
 
    //! \brief Test if a part belong at the part table
    //! \param inPart Part to be tested
    Dtk_bool hasPart(Dtk_KinPartPtr inPart);
    //! \brief Returns the position of the part
    //! \param inPart Part required
    //!
    //! Returns -1 if the part doesn't found
    int getPartPosition(Dtk_KinPartPtr inPart);
    //! \brief Returns the position of the part that have the same numChild attribut
    //! \param inPart Part required
    //!
    //! Returns -1 if the part doesn't found
    int getPartPositionByNumChild(Dtk_KinPartPtr inPart);
    //! \brief Returns the part by it numChild attribute
    Dtk_KinPartPtr getPartByNumChild(int inNumChild);
    //! \brief Returns Dtk_KinPart at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns NULL
    Dtk_KinPartPtr getPart(Dtk_Size_t pos);
    //! \brief Adds inPart at the part table
    //! \param inPart part to be added
    //!
    //! If the part table doesn't contain inPart, inPart is added
    void addPart(Dtk_KinPartPtr inPart);
    //! \brief Returns the part tab size
    Dtk_Size_t getPartSize();
    //! \brief Returns the part by it instanceName attribute
    Dtk_KinPartPtr getPartByInstanceName(Dtk_string & inName);
 
    //! \brief Test if a constraint belong at the constraint table
    //! \param inConstraint Constraint to be tested
    Dtk_bool hasConstraint(Dtk_KinConstraintPtr inConstraint);
    //! \brief Returns the position of the constraint
    //! \param inConstraint Constraint required
    //!
    //! Returns -1 if the constraint doesn't found
    int getConstraintPosition(Dtk_KinConstraintPtr inConstraint);
    //! \brief Returns Dtk_KinConstraint at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns \code NULL \endcode
    Dtk_KinConstraintPtr getConstraint(Dtk_Size_t pos);
    //! \brief Add inConstraint at the constraint table
    //! \param inConstraint constraint to be added
    //!
    //! If the constraint table doesn't contain inConstraint, inConstraint is added
    void addConstraint(Dtk_KinConstraintPtr inConstraint);
    //! \brief Return the attribute tab size
    Dtk_Size_t getConstraintSize();
 
    //! \brief Test if a joint belong at the joint table
    //! \param inJoint Joint to be tested
    Dtk_bool hasJoint(Dtk_KinJointPtr inJoint);
    //! \brief Returns the position of the joint
    //! \param inJoint Joint required
    //!
    //! Returns -1 if the joint doesn't found
    int getJointPosition(Dtk_KinJointPtr inJoint);
    //! \brief Returns Dtk_KinJoint at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns \code NULL \endcode
    Dtk_KinJointPtr getJoint(Dtk_Size_t pos);
    //! \brief Add inJoint at the joint table
    //! \param inJoint joint to be added
    //!
    //! If the joint table doesn't contain inJoint, inJoint is added
    void addJoint(Dtk_KinJointPtr inJoint);
    //! \brief Return the attribute tab size
    Dtk_Size_t getJointSize();
 
    //! \brief Test if a command belong at the command table
    //! \param inCommand command to be tested
    Dtk_bool hasCommand(Dtk_KinCommandPtr inCommand);
    //! \brief Returns the position of the command
    //! \param inCommand command required
    //!
    //! Returns -1 if the command doesn't found
    int getCommandPosition(Dtk_KinCommandPtr inCommand);
    //! \brief Returns Dtk_KinCommand at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns NULL
    Dtk_KinCommandPtr getCommand(Dtk_Size_t pos);
    //! \brief Add inCommand at the command table
    //! \param inCommand command to be added
    //!
    //! If the command table doesn't contain inCommand, inCommand is added
    void addCommand(Dtk_KinCommandPtr inCommand);
    //! \brief Return the attribute tab size
    Dtk_Size_t getCommandSize();
 
    //! \brief Test if a mechanism belong at the mechanism table
    //! \param inMechanism mechanism to be tested
    Dtk_bool hasMechanism(Dtk_KinMechanismPtr inMechanism);
    //! \brief Returns the position of the mechanism
    //! \param inMecha Mechanism required
    //!
    //! Returns -1 if the mechanism doesn't found
    int getMechanismPosition(Dtk_KinMechanismPtr inMecha);
    //! \brief Returns Dtk_KinMechanism at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns \code NULL \endcode
    Dtk_KinMechanismPtr getMechanism(Dtk_Size_t pos);
    //! \brief Add inMechanism at the mechanism table
    //! \param inMechanism mechanism to be added
    //!
    //! If the mechanism table doesn't contain inMechanism, inMechanism is added
    void addMechanism(Dtk_KinMechanismPtr inMechanism);
    //! \brief Return the mechanism tab size
    Dtk_Size_t getMechanismSize();
    //! \brief Returns the mechanism associated at command inCommand
    Dtk_KinMechanismPtr getMechanismByCommand(Dtk_KinCommandPtr inCOmmand);
    //! \brief Returns the mechanism associated at joint inJoint
    Dtk_KinMechanismPtr getMechanismByJoint(Dtk_KinJointPtr inJoint);
    //! \brief Returns the mechanism associated at speed/acceleration inSpeed
    Dtk_KinMechanismPtr getMechanismBySpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
 
    //! \brief Test if a parameter belong at the parameter table
    //! \param inParameter parameter to be tested
    Dtk_bool hasParameter(Dtk_KinParameterPtr inParameter);
    //! \brief Returns the position of the parameter
    //! \param inPara Parameter required
    //!
    //! Returns -1 if the parameter doesn't found
    int getParameterPosition(Dtk_KinParameterPtr inPara);
    //! \brief Returns Dtk_KinParameter at position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns \code NULL \endcode
    Dtk_KinParameterPtr getParameter(Dtk_Size_t pos);
    //! \brief Add inParameter at the parameter table
    //! \param inParameter parameter to be added
    //!
    //! If the parameter table doesn't contain inParameter, inParameter is added
    void addParameter(Dtk_KinParameterPtr inParameter);
    //! \brief Return the parameter tab size
    Dtk_Size_t getParameterSize();
 
    //! \brief Sets the product object represented all element compound the CATProduct file
    void setProduct(Dtk_KinProductPtr inProd);
 
     //! \brief Sets the product object represented all element compound the CATProduct file
     Dtk_KinProductPtr getProduct();
 
protected:
    //! \brief All parts referenced into another object, are defined at this table.
    Dtk_KinPartTab _parts;
    //! \brief All constraints referenced into another object, are defined at this table.
    Dtk_KinConstraintTab _constraints;
    //! \brief All joints referenced into another object, are defined at this table.
    Dtk_KinJointTab _joints;
    //! \brief All commands referenced into another object, are defined at this table.
    Dtk_KinCommandTab _commands;
    //! \brief All mechanisms defined a kinematic
    Dtk_KinMechanismTab _mechanisms;
    //! \brief Parameter can be used for law
    Dtk_KinParameterTab _parameters;
 
    //! \brief Tree representation for the component (additional of part table)
    Dtk_KinProductPtr _product;
 
};
 
 
//! \ingroup KinClasses
//! \class Dtk_KinFormula
//! \brief Dtk_KinFormula represents the formula defined the law.
//!
//! A formula is linked at a law object.
//! \SmartPtr{Dtk_KinFormulaPtr}
class Dtk_KinFormula : public Dtk_Object
{
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_FORMULA
          };
 
          //! \brief Default constructor 
          Dtk_KinFormula();
          //! \brief Copy constructor
          //! \param inFormula the Dtk_KinFormula to be copied
          Dtk_KinFormula(const Dtk_KinFormula & inFormula);
 
          //! \brief Destructor
          ~Dtk_KinFormula();
 
          friend class Dtk_SmartPtr<Dtk_KinFormula>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinFormula &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinFormula* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinFormula*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_FORMULA - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_FORMULA; }
 
          //! \CreateBase
          static Dtk_KinFormulaPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinFormulaPtr release(Dtk_KinFormulaPtr inFormula);
 
    //! \brief Write Dump file for formula
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinFormula formula;
    //! formula.setName(Dtk_string("sample formula"));
    //! formula.setId(1);
    //! formula.Dump(file);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <formula name="sample formula" id="1">
    //!   <attributFormula comment="" formula="" parameter=""/>
    //! </formula>
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Returns the formula name
    Dtk_string getName();
    //! \brief Sets the formula name
    //! \param inName formula name
    void setName(Dtk_string inName);
    //! \brief Returns the formula id
    int getId();
    //! \brief Sets the formula id
    //! \param inId formula id
    void setId(int inId);
    //! \brief Returns the formula comment
    Dtk_string getComment();
    //! \brief Sets the formula comment
    //! \param inComment formula comment
    void setComment(Dtk_string inComment);
    //! \brief Returns the formula
    Dtk_string getFormula();
    //! \brief Sets the formula
    //! \param inFormula formula
    void setFormula(Dtk_string inFormula);
    //! \brief Returns the formula parameter
    Dtk_string getParam();
    //! \brief Sets the formula parameter
    //! \param inParam formula parameter
    void setParam(Dtk_string inParam);
protected:
    Dtk_string _name;
    int _ID;
 
    Dtk_string _comment;
    Dtk_string _formula;
    Dtk_string _param;
private:
};
 
//! \ingroup KinClasses
//! \class Dtk_KinCurve
//! \brief Dtk_KinCurve represents a curve associated at a law.
class Dtk_KinCurve : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_CURVE
          };
 
          //! \brief Default constructor 
          Dtk_KinCurve();
          //! \brief Copy constructor
          //! \param part the Dtk_KinSpeedAcceleration to be copied
          Dtk_KinCurve(const Dtk_KinCurve & inSketch);
 
          //! \brief Destructor
          ~Dtk_KinCurve();
 
          friend class Dtk_SmartPtr<Dtk_KinCurve>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinCurve &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinCurve* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinCurve*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_CURVE - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_CURVE; }
 
          //! \CreateBase
          static Dtk_KinCurvePtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinCurvePtr release(Dtk_KinCurvePtr inCurve);
 
    //! \brief Write Dump file for mechanism speed/acceleration
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinSpeedAcceleration speedAcc;
    //! speedAcc.setName(Dtk_string("sample speed/acceleration"));
    //! speedAcc.setId(1);
    //! speedAcc.setIdFile(5);
    //! speedAcc.Dump(file, true);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Returns the file name associated at the curve
    Dtk_string getFileName();
    //! \brief Sets the file name associated at the curve
    void setFileName(const Dtk_string & inFileName);
    //! \brief Returns the block id
    int getIdBlock();
    //! \brief Sets the block id
    void setIdBlock(int inId);
    //! \brief Returns the entity and this type at position inPos
    //! \param inPos position of element
    //! \param outEntity An out parameter
    //! \param outType An out parameter
    //!
    //! If position is out bounds returns NULL
    void getEntity(Dtk_Size_t inPos, void ** outEntity, enum type_detk * outType);
    //! \brief Add an entity and this type at the entity table
    //! \param inEntity Entity to be added
    //! \param inType Entity type
    void addEntity(void * inEntity, enum type_detk inType);
    //! \brief Return the size of the entity tab
    Dtk_Size_t getEntitySize();
protected:
    Dtk_string _fileName;
    int _idBlock;
    Dtk_tab<type_detk> _typeEntity;
    Dtk_tab<void *> _entity;
private:
};
 
 
 
//! \ingroup KinClasses
//! \class Dtk_KinLaw
//! \brief Dtk_KinLaw represents a law associated at a command.
//!
//! A law is linked at a mechanism object.
//! \SmartPtr{Dtk_KinLawPtr}
class Dtk_KinLaw : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_LAW
          };
 
          //! \brief Default constructor 
          Dtk_KinLaw();
          //! \brief Copy constructor
          //! \param inLaw the Dtk_KinLaw to be copied
          Dtk_KinLaw(const Dtk_KinLaw& inLaw);
 
          //! \brief Destructor
          ~Dtk_KinLaw();
 
          friend class Dtk_SmartPtr<Dtk_KinLaw>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinLaw &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinLaw* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinLaw*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_LAW - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_LAW; }
 
          //! \CreateBase
          static Dtk_KinLawPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinLawPtr release(Dtk_KinLawPtr inLaw);
 
    //! \brief Write Dump file for law
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinLaw law;
    //! law.setName(Dtk_string("sample law"));
    //! law.setId(1);
    //! law.Dump(file, true);
    //! \endcode
    //!
    //! \b Result
    //! \code
    //! <law name="sample law" id="1">
    //!   <attributLaw comment="" synchrone="" active="" algo=""/>
    //!   <!-- formula.Dump(inFile) -->
    //!   <parameters>
    //!     <!-- parameter.Dump(inFile) -->
    //!   </parameters>
    //! </law>
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Test if 2 Dtk_KinLaw is equal
    //!
    //! Compare the id attributes.
    //! \param inPart Dtk_KinLaw to be tested
    Dtk_bool isEqual(Dtk_KinLawPtr inLaw);
 
    //! \brief Returns the law name
    Dtk_string getName();
    //! \brief Sets the law name
    //! \param inName law name
    void setName(Dtk_string inName);
    //! \brief Returns the law id
    int getId();
    //! \brief Sets the law id
    //! \param inId law id
    void setId(int inId);
    //! \brief Returns the law comment
    Dtk_string getComment();
    //! \brief Sets the law comment
    //! \param inComment law comment
    void setComment(Dtk_string inComment);
    //! \brief Returns the synchrone attribute
    int getSynchrone();
    //! \brief Sets the synchrone attribute
    //! \param inSynchrone synchrone attribute
    void setSynchrone(int inSynchrone);
    //! \brief Returns the law expression (formula)
    Dtk_KinFormulaPtr getExpression();
    //! \brief Sets the formula 
    //! \param inExpression formula
    void setExpression(Dtk_KinFormulaPtr inExpression);
 
    //! \brief Add a curve at the parameter in
    //! \param inCurve Curve to be added
    void addCurve(Dtk_KinCurvePtr inCurve);
    //! \brief Returns the curve at the position inPos
    //! \param inPos position of element
    //!
    //! If position is out bounds returns NULL
    Dtk_KinCurvePtr getCurve(Dtk_Size_t inPos);
    //! \brief Return the size of the curve tab
    Dtk_Size_t getCurveSize();
 
    //! \brief Add a paramater at the parameter table
    //! \param param Parameter to be added
    void addParameter(Dtk_KinParameterPtr param);
    //! \brief Returns the parameter table
    //! The last is the out parameter
    Dtk_KinParameterTab getParameter();
    //! \brief Sets the parameter table
    //! \param inParamOut parameter table
    void setParameter(Dtk_KinParameterTab inParamOut);
    //! \brief Returns the active attribute
    int getActive();
    //! \brief Sets the active attribute
    //! \param inActive active attribute
    void setActive(int inActive);
 
    void setAlgo(int inAlgo);
    int getAlgo();
protected:
    Dtk_string _name;
    int _ID;
 
    Dtk_string _comment;
    int _synchrone;
    Dtk_KinFormulaPtr _expression;
 
    // paramIn (courbe)
    Dtk_KinCurveTab _curve;
 
    Dtk_KinParameterTab _param;
    //! value:
    //!  - 1: deactivate
    //!  - 2: activate
    int _active;
 
    int _algo;
private:
};
 
//! \ingroup KinClasses
//! \class Dtk_KinSpeedAcceleration
//! \brief Dtk_KinSpeedAcceleration represents a mechanism speed/acceleration
//! \SmartPtr{Dtk_KinSpeedAccelerationPtr}
class Dtk_KinSpeedAcceleration : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_SPEEDACCELERATION
          };
 
          //! \brief Default constructor 
          Dtk_KinSpeedAcceleration();
          //! \brief Copy constructor
          //! \param inSpeedAcceleration the Dtk_KinSpeedAcceleration to be copied
          Dtk_KinSpeedAcceleration(const Dtk_KinSpeedAcceleration& inSpeedAcceleration);
 
          //! \brief Destructor
          ~Dtk_KinSpeedAcceleration();
 
          friend class Dtk_SmartPtr<Dtk_KinSpeedAcceleration>;
     private:
          void _Init();
          void _Copy(const Dtk_KinSpeedAcceleration &kin);
          void _Reset();
 
     public:
 
          //! \DtkDynamicType
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          //! \DtkDynamicCast
          static Dtk_KinSpeedAcceleration* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinSpeedAcceleration*>(s); 
               return NULL; 
          } 
 
          //! \return The type of the entity type - DTK_TYPE_KIN_SPEEDACCELERATION - 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_SPEEDACCELERATION; }
 
          //! \CreateBase
          static Dtk_KinSpeedAccelerationPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    //! \brief Delete object
    static Dtk_KinSpeedAccelerationPtr release(Dtk_KinSpeedAccelerationPtr inSpeedAcceleration);
 
    //! \brief Write Dump file for mechanism speed/acceleration
    //! \param inFile the output file
    //!
    //! \b Sample
    //! \code
    //! Dtk_string fileName = ...;
    //! File * file = fileName.OpenFile(DTK_W);
    //!
    //! Dtk_KinSpeedAcceleration speedAcc;
    //! speedAcc.setName(Dtk_string("sample speed/acceleration"));
    //! speedAcc.setId(1);
    //! speedAcc.Dump(file, true);
    //! \endcode
    Dtk_status Dump(FILE * inFile);
 
    //! \brief Test if 2 Dtk_KinSpeedAcceleration is equal
    //! \param inPart Dtk_KinSpeedAcceleration to be tested
    Dtk_bool operator==(Dtk_KinSpeedAcceleration & inSpeed);
    //! \brief Test if 2 Dtk_KinSpeedAcceleration is equal
    //! \param inPart Dtk_KinSpeedAcceleration to be tested
    Dtk_bool isEqual(Dtk_KinSpeedAccelerationPtr inSpeed);
 
    //! \brief Returns the name of speed/acceleration
    Dtk_string getName();
    //! \brief Sets the name of speed/acceleration
    //! \param inName name of speed/acceleration
    void setName(Dtk_string inName);
    //! \brief Returns the id of speed/acceleration
    int getId();
    //! \brief Sets the id of speed/acceleration
    //! \param inId id of speed/acceleration
    void setId(int inId);
 
    //! \brief Returns the reference production part
    Dtk_KinPartPtr getRefProd();
    //! \brief Sets the reference production part
    //! \param inPart reference production
    void setRefProd(Dtk_KinPartPtr inPart);
    Dtk_KinConnectorPtr getPoint();
    void setPoint(Dtk_KinConnectorPtr inPart);
 
    //! \brief Returns the point X
    Dtk_KinParameterPtr getPtX();
    //! \brief Sets the point X
    //! \param inParam point X
    void setPtX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the point Y
    Dtk_KinParameterPtr getPtY();
    //! \brief Sets the point Y
    //! \param inParam point Y
    void setPtY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the point Z
    Dtk_KinParameterPtr getPtZ();
    //! \brief Sets the point Z
    //! \param inParam point Z
    void setPtZ(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the linear speed for X axis
    Dtk_KinParameterPtr getLinearSpeedX();
    //! \brief Sets the linear speed for X axis
    //! \param inParam linear speed
    void setLinearSpeedX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear speed for Y axis
    Dtk_KinParameterPtr getLinearSpeedY();
    //! \brief Sets the linear speed for Y axis
    //! \param inParam linear speed
    void setLinearSpeedY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear speed for Z axis
    Dtk_KinParameterPtr getLinearSpeedZ();
    //! \brief Sets the linear speed for Z axis
    //! \param inParam linear speed
    void setLinearSpeedZ(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear speed
    Dtk_KinParameterPtr getLinearSpeed();
    //! \brief Sets the linear speed
    //! \param inParam linear speed
    void setLinearSpeed(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the linear acceleration for X axis
    Dtk_KinParameterPtr getLinearAccelerationX();
    //! \brief Sets the linear acceleration for X axis
    //! \param inParam the linear acceleration
    void setLinearAccelerationX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear acceleration for Y axis
    Dtk_KinParameterPtr getLinearAccelerationY();
    //! \brief Sets the linear acceleration for Y axis
    //! \param inParam the linear acceleration
    void setLinearAccelerationY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear acceleration for Z axis
    Dtk_KinParameterPtr getLinearAccelerationZ();
    //! \brief Sets the linear acceleration for Z axis
    //! \param inParam the linear acceleration
    void setLinearAccelerationZ(Dtk_KinParameterPtr inParam);
    //! \brief Returns the linear acceleration
    Dtk_KinParameterPtr getLinearAcceleration();
    //! \brief Sets the linear acceleration 
    //! \param inParam the linear acceleration
    void setLinearAcceleration(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the angular speed for X angle
    Dtk_KinParameterPtr getAngularSpeedX();
    //! \brief Sets the angular speed for X angle
    //! \param inParam angular speed
    void setAngularSpeedX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular speed for Y angle
    Dtk_KinParameterPtr getAngularSpeedY();
    //! \brief Sets the angular speed for Y angle
    //! \param inParam angular speed
    void setAngularSpeedY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular speed for Z angle
    Dtk_KinParameterPtr getAngularSpeedZ();
    //! \brief Sets the angular speed for Z angle
    //! \param inParam angular speed
    void setAngularSpeedZ(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular speed
    Dtk_KinParameterPtr getAngularSpeed();
    //! \brief Sets the angular speed
    //! \param inParam angular speed
    void setAngularSpeed(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the angular acceleration for X angle
    Dtk_KinParameterPtr getAngularAccelerationX();
    //! \brief Sets the angular acceleration for X angle
    //! \param inParam the angular acceleration
    void setAngularAccelerationX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular acceleration for Y angle
    Dtk_KinParameterPtr getAngularAccelerationY();
    //! \brief Sets the angular acceleration for Y angle
    //! \param inParam the angular acceleration
    void setAngularAccelerationY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular acceleration for Z angle
    Dtk_KinParameterPtr getAngularAccelerationZ();
    //! \brief Sets the angular acceleration for Z angle
    //! \param inParam the angular acceleration
    void setAngularAccelerationZ(Dtk_KinParameterPtr inParam);
    //! \brief Returns the angular acceleration
    Dtk_KinParameterPtr getAngularAcceleration();
    //! \brief Sets the angular acceleration
    //! \param inParam the angular acceleration
    void setAngularAcceleration(Dtk_KinParameterPtr inParam);
 
    //! \brief Returns the Cir X
    Dtk_KinParameterPtr getCirX();
    //! \brief Sets the Cir X
    //! \param inParam Cir X
    void setCirX(Dtk_KinParameterPtr inParam);
    //! \brief Returns the Cir Y
    Dtk_KinParameterPtr getCirY();
    //! \brief Sets the Cir Y
    //! \param inParam Cir Y
    void setCirY(Dtk_KinParameterPtr inParam);
    //! \brief Returns the Cir Z
    Dtk_KinParameterPtr getCirZ();
    //! \brief Sets the Cir Z
    //! \param inParam Cir Z
    void setCirZ(Dtk_KinParameterPtr inParam);
private:
protected:
    Dtk_string _name;
    int _ID;
    Dtk_string _idFile;
    Dtk_KinPartPtr _refProd;
    Dtk_KinConnectorPtr _point; // -> connector
    // attribut axis ref vers un catpart
 
    //! \brief Point
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    Dtk_KinParameterPtr _pt[3];
    //! \brief Linear speed
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    //!  - 3: general
    Dtk_KinParameterPtr _linearSpeed[5];
    //! \brief linear acceleration
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    //!  - 3: general
    Dtk_KinParameterPtr _linearAcc[5];
    //! \brief Angular speed
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    //!  - 3: general
    Dtk_KinParameterPtr _angularSpeed[5];
    //! \brief Angular acceleration
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    //!  - 3: general
    Dtk_KinParameterPtr _angularAcc[5];
    //! \brief Cir
    //!
    //! Position
    //!  - 0: x
    //!  - 1: y
    //!  - 2: z
    Dtk_KinParameterPtr _cir[3];
};
 
#endif