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_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;
 
void Dtk_SetReleaseByPartFileName(Dtk_string & inFileName, int inRelease);
 
Dtk_ConnectorTab Dtk_GetConnectorsByPartFileName(Dtk_string & inFileName);
 
Dtk_bool hasConnector(Dtk_KinConnectorPtr inConnector);
 
Dtk_bool hasConnector(Dtk_KinConnectorPtr inConnector);
 
Dtk_KinPartPtr searchPartByNumChild(int inNumChild);
#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;
 
 
 
 
 
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
};
 
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
};
 
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
};
 
Dtk_KinematicPtr Dtk_GetKinematics();
 
Dtk_status Dtk_DumpKinematics(const Dtk_string &inFileName);
 
Dtk_status Dtk_DeleteKinematics();
 
void Dtk_SetKinematics(Dtk_KinematicPtr inKinematic);
 
 
class Dtk_KinNamedValue: public Dtk_Object
{
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_KIN_NAMED_VALUE
     };
 
     Dtk_KinNamedValue();
     Dtk_KinNamedValue(const Dtk_KinNamedValue& att);
 
     ~Dtk_KinNamedValue();
 
     friend class Dtk_SmartPtr<Dtk_KinNamedValue>;
private:
     void _Init();
     void _Copy(const Dtk_KinNamedValue &kin);
     void _Reset();
 
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Object::DtkDynamicType(inId); 
     }
 
     static Dtk_KinNamedValue* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_KinNamedValue*>(s); 
          return NULL; 
     } 
 
     type_detk get_type_detk() const { return DTK_TYPE_KIN_NAMED_VALUE; }
 
     static Dtk_KinNamedValuePtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinNamedValuePtr release(Dtk_KinNamedValuePtr inNamedValue);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    double getValue();
    void setValue(double inValue);
private:
protected:
    Dtk_string _name;
    double _valeur;
};
 
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
     };
 
     Dtk_KinParameter();
     Dtk_KinParameter(const Dtk_KinParameter& param);
 
     ~Dtk_KinParameter();
     friend class Dtk_SmartPtr<Dtk_KinParameter>;
private:
     void _Init();
     void _Copy(const Dtk_KinParameter &kin);
     void _Reset();
public:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Object::DtkDynamicType(inId); 
     }
 
     static Dtk_KinParameter* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_KinParameter*>(s); 
          return NULL; 
     } 
 
     type_detk get_type_detk() const { return DTK_TYPE_KIN_PARAMETER; }
 
     static Dtk_KinParameterPtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //static 
     Dtk_string _RANGE;
 
    static Dtk_KinParameterPtr release(Dtk_KinParameterPtr inParameter);
 
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified=DTK_FALSE);
    Dtk_bool isEqual(Dtk_KinParameterPtr inParam);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    Dtk_KinNamedValuePtr getNamedValue();
    void setNamedValue(Dtk_KinNamedValuePtr inAtt);
 
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    void addAttribute(Dtk_string inAttribute);
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    Dtk_Size_t getAttributeSize();
 
    DTK_KINEMATIC_TYPE getParentType();
    void setParentType(DTK_KINEMATIC_TYPE inType);
    void * getParentElement();
    void setParentElement(void * inParent);
 
    double getRange(int inPosition);
    void setRange(double inRange[4]);
    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;
 
    double _range[4];
};
 
 
class Dtk_KinProduct: public Dtk_Object
{
 
protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_PRODUCT
          };
 
          Dtk_KinProduct();
          Dtk_KinProduct(const Dtk_KinProduct& inProd);
 
          ~Dtk_KinProduct();
          friend class Dtk_SmartPtr<Dtk_KinProduct>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinProduct &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinProduct* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinProduct*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_PRODUCT; }
 
          static Dtk_KinProductPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    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);
 
    Dtk_string& name();
    int& id();
    int& numChild();
    Dtk_string& instanceName();
    Dtk_string& fileName();
 
    Dtk_Size_t getNbPart();
    void addPart(Dtk_KinPartPtr inPart);
    Dtk_KinPartPtr getPart(Dtk_Size_t inPos);
    Dtk_Size_t getNbProduct();
    void addProduct(Dtk_KinProductPtr inProduct);
    Dtk_KinProductPtr getProduct(Dtk_Size_t inPos);
    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:
};
 
 
 
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
          };
 
          Dtk_KinConstraint();
          Dtk_KinConstraint(const Dtk_KinConstraint& constraint);
 
          ~Dtk_KinConstraint();
 
          friend class Dtk_SmartPtr<Dtk_KinConstraint>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinConstraint &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinConstraint* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinConstraint*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_CONSTRAINT; }
 
          static Dtk_KinConstraintPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //static 
     Dtk_string _MODE_INTEGER;
    //static 
     Dtk_string _VALUE;
    //static 
     Dtk_string _ORIENTATION;
    //static 
     Dtk_string _REFERENCE;
    //static 
     Dtk_string _POSITION;
 
    static Dtk_KinConstraintPtr release(Dtk_KinConstraintPtr inPart);
 
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    Dtk_bool operator==(Dtk_KinConstraint & inConstraint);
    Dtk_bool isEqual(Dtk_KinConstraintPtr inConstraint);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
 
  
    void addConnector(Dtk_KinConnectorPtr inConnector);
    Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition);
    Dtk_Size_t getConnectorSize();
    void replaceConnector(Dtk_Size_t inPosition, Dtk_KinConnectorPtr inConnector);
 
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    void addAttribute(Dtk_string inAttribute);
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    Dtk_Size_t getAttributeSize();
 
    Dtk_KinParameterPtr getValue();
    void setValue(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getOrientation();
    void setOrientation(Dtk_KinParameterPtr inParam);
    int getModeInteger();
    void setModeInteger(int inMode);
    Dtk_KinParameterPtr getReference();
    void setReference(Dtk_KinParameterPtr inParam);
    Dtk_transfo getPosition();
    void setPosition(Dtk_transfo transfo);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    Dtk_KinConnectorTab _connectors;
 
    Dtk_StringTab _attributeTable;
 
    Dtk_KinParameterPtr _value;
    Dtk_KinParameterPtr _orientation;
    int _modeInteger;
    Dtk_KinParameterPtr _reference;
    Dtk_transfo _position;
};
 
 
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
          };
 
          Dtk_KinJoint();
          Dtk_KinJoint(const Dtk_KinJoint& joint);
 
          ~Dtk_KinJoint();
          friend class Dtk_SmartPtr<Dtk_KinJoint>;
 
 
     private:
          void _Init();
          void _Copy(const Dtk_KinJoint &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinJoint* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinJoint*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_JOINT; }
 
          static Dtk_KinJointPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
    //static
     Dtk_string _CONSTRAINT;
    //static
     Dtk_string _PARAMETER1;
    //static
     Dtk_string _PARAMETER2;
    //static
     Dtk_string _FIX_TOGETHER;
    //static
     Dtk_string _ABSOLUT_POS1;
    //static
     Dtk_string _ABSOLUT_POS2;
    //static
     Dtk_string _UPPER_LIMIT1;
    //static 
     Dtk_string _LOWER_LIMIT1;
    //static 
     Dtk_string _UPPER_LIMIT2;
    //static 
     Dtk_string _LOWER_LIMIT2;
    //static 
     Dtk_string _PART3;
    //static 
     Dtk_string _LOCAL_FRAME3;
    //static 
     Dtk_string _LOCAL_FRAME4;
    //static 
     Dtk_string _JOINT1;
    //static
     Dtk_string _JOINT2;
    //static 
     Dtk_string _RATIO;
    //static 
     Dtk_string _RATIO_PARAMETER;
    //static
     Dtk_string _CONNECTOR;
 
 
    static Dtk_KinJointPtr release(Dtk_KinJointPtr inJoint);
 
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    Dtk_bool operator==(Dtk_KinJoint & inJoint);
    Dtk_bool isEqual(Dtk_KinJointPtr inJoint);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    JOINT_TYPE getType();
    void setType(int inType);
    Dtk_KinPartPtr getPart1();
    void setPart1(Dtk_KinPartPtr inPart);
    Dtk_KinPartPtr getPart2();
    void setPart2(Dtk_KinPartPtr inPart);
    Dtk_transfo getLocalFrame1();
    void setLocalFrame1(Dtk_transfo inTransfo);
    Dtk_transfo getLocalFrame2();
    void setLocalFrame2(Dtk_transfo inTransfo);
    int getCompoundType();
    void setCompoundType(int inCompoundtype);
 
    Dtk_bool hasAttribute(Dtk_string inAttributeName);
    void addAttribute(Dtk_string inAttribute);
    Dtk_string getAttribute(Dtk_Size_t inPosition);
    Dtk_Size_t getAttributeSize();
 
    Dtk_bool hasConstraint(Dtk_KinConstraintPtr inConstraint);
    Dtk_KinConstraintPtr getConstraint(Dtk_Size_t inPosition);
    void addConstraint(Dtk_KinConstraintPtr inConstraint);
    Dtk_Size_t getConstraintSize();
    Dtk_KinConnectorPtr getConnector(Dtk_Size_t inPosition);
    void addConnector(Dtk_KinConnectorPtr inConnector);
    Dtk_Size_t getConnectorSize();
    Dtk_KinConnectorTab getConnectorTab();
    double getParameter1();
    void setParameter1(double inParam);
    double getParameter2();
    void setParameter2(double inParam);
    Dtk_KinConstraintPtr getFixTogether();
    void setFixTogether(Dtk_KinConstraintPtr inFix);
    Dtk_transfo getAbsolutPos1();
    void setAbsolutPos1(Dtk_transfo inTransfo);
    Dtk_transfo getAbsolutPos2();
    void setAbsolutPos2(Dtk_transfo inTransfo);
    double getUpperLimit1();
    void setUpperLimit1(double inVal);
    double getLowerLimit1();
    void setLowerLimit1(double inVal);
    double getUpperLimit2();
    void setUpperLimit2(double inVal);
    double getLowerLimit2();
    void setLowerLimit2(double inVal);
    Dtk_KinPartPtr getPart3();
    void setPart3(Dtk_KinPartPtr inPart);
    Dtk_transfo getLocalFrame3();
    void setLocalFrame3(Dtk_transfo inTransfo);
    Dtk_transfo getLocalFrame4();
    void setLocalFrame4(Dtk_transfo inTransfo);
    Dtk_KinJointPtr getJoint1();
    void setJoint1(Dtk_KinJointPtr inJoint);
    Dtk_KinJointPtr getJoint2();
    void setJoint2(Dtk_KinJointPtr inJoint);
    double getRatio();
    void setRatio(double inVal);
    Dtk_KinParameterPtr getRatioParameter();
    void setRatioParameter(Dtk_KinParameterPtr inParam);
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    JOINT_TYPE _type;
    Dtk_KinPartPtr _part1;
    Dtk_KinPartPtr _part2;
    Dtk_transfo _localframe1;
    Dtk_transfo _localframe2;
    int _compoundType;
 
    Dtk_StringTab _attributeTable;
 
    Dtk_KinConstraintTab _constraints;
    Dtk_KinConnectorTab _connectors;
    double _parameter1;
    double _parameter2;
    Dtk_KinConstraintPtr _fixTogether;
    Dtk_transfo _absolutepos1;
    Dtk_transfo _absolutepos2;
    double _upperlimit1;
    double _lowerlimit1;
    double _upperlimit2;
    double _lowerlimit2;
    Dtk_KinPartPtr _part3;
    Dtk_transfo _localframe3;
    Dtk_transfo _localframe4;
    Dtk_KinJointPtr _joint1;
    Dtk_KinJointPtr _joint2;
    double _ratio;
    Dtk_KinParameterPtr _ratioParm;
};
 
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
          };
 
          Dtk_KinCommand();
          Dtk_KinCommand(const Dtk_KinCommand& cmd);
 
          ~Dtk_KinCommand();
 
          friend class Dtk_SmartPtr<Dtk_KinCommand>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinCommand &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinCommand* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinCommand*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_COMMAND; }
 
          static Dtk_KinCommandPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
public:
 
    static Dtk_KinCommandPtr release(Dtk_KinCommandPtr inCommand);
 
    Dtk_status Dump(FILE * inFile, Dtk_bool simplified);
 
    Dtk_bool operator==(Dtk_KinCommand & inCommand);
    Dtk_bool isEqual(Dtk_KinCommandPtr inCommand);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    COMMAND_TYPE getType();
    void setType(int inType);
    double getValue();
    void setValue(double inValue);
    Dtk_KinJointPtr getJoint();
    void setJoint(Dtk_KinJointPtr inJoint);
    Dtk_KinParameterPtr getParameter();
    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
    COMMAND_TYPE _type;
    double _value;
    Dtk_KinJointPtr _joint;
    Dtk_KinParameterPtr _parameter;
};
 
 
class Dtk_KinFixPart: public Dtk_Object
{
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_FIXPART
          };
 
          Dtk_KinFixPart();
          Dtk_KinFixPart(const Dtk_KinFixPart & fixPart);
 
          ~Dtk_KinFixPart();
          friend class Dtk_SmartPtr<Dtk_KinFixPart>;
     private:
          void _Init();
          void _Copy(const Dtk_KinFixPart &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinFixPart* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinFixPart*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_FIXPART; }
 
          static Dtk_KinFixPartPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinFixPartPtr release(Dtk_KinFixPartPtr inFixPart);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    Dtk_KinConstraintPtr getConstraint();
    void setConstraint(Dtk_KinConstraintPtr inConstraint);
    Dtk_KinPartPtr getPart();
    void setPart(Dtk_KinPartPtr inPart);
private:
protected:
    Dtk_string _name;
    int _ID;
    Dtk_KinConstraintPtr _fixcst;
    Dtk_KinPartPtr _fixpart;
};
 
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
          };
 
          Dtk_KinMechanism();
          Dtk_KinMechanism(const Dtk_KinMechanism& mecha);
 
          ~Dtk_KinMechanism();
          friend class Dtk_SmartPtr<Dtk_KinMechanism>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinMechanism &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinMechanism* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinMechanism*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_MECHANISM; }
 
          static Dtk_KinMechanismPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
public:
 
    static Dtk_KinMechanismPtr release(Dtk_KinMechanismPtr inMechanism);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_bool operator==(Dtk_KinMechanism & inMechanism);
    Dtk_bool isEqual(Dtk_KinMechanismPtr inMechanism);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    Dtk_string getVersion();
    void setVersion(Dtk_string inVersion);
    Dtk_bool hasJoint(Dtk_KinJointPtr inJoint);
    void addJoint(Dtk_KinJointPtr inJoint);
    Dtk_KinJointPtr getJoint(Dtk_Size_t inPos);
    Dtk_Size_t getJointSize();
    Dtk_bool hasCommand(Dtk_KinCommandPtr inCmd);
    void addCommand(Dtk_KinCommandPtr inCmd);
    Dtk_KinCommandPtr getCommand(Dtk_Size_t inPos);
    Dtk_Size_t getCommandSize();
    Dtk_KinFixPartPtr getFixPart();
    void setFixPart(Dtk_KinFixPartPtr inFixPart);
    Dtk_KinParameterPtr getParamTime();
    void setParamTime(Dtk_KinParameterPtr inParam);
    Dtk_bool hasLaw(Dtk_KinLawPtr inLaw);
    void addLaw(Dtk_KinLawPtr inLaw);
    Dtk_KinLawPtr getLaw(Dtk_Size_t inPos);
    Dtk_Size_t getLawSize();
    void deleteLaw(Dtk_KinLawPtr inLaw);
 
    Dtk_bool hasSpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
    void addSpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
    Dtk_KinSpeedAccelerationPtr getSpeedAcceleration(Dtk_Size_t inPos);
    Dtk_Size_t getSpeedAccelerationSize();
private:
    int _compteur;
protected:
    Dtk_string _name;
    int _ID;
    Dtk_string _version;
    Dtk_KinJointTab _jointList;
    Dtk_KinCommandTab _cmdList;
    Dtk_KinFixPartPtr _fixPart;
    Dtk_KinParameterPtr _mechParamTime;
    Dtk_KinLawTab _laws;
    Dtk_KinSpeedAccelerationTab _speedAcc;
};
 
 
 
class Dtk_Kinematic: public Dtk_Entity
{
 
protected:
     //  struct Dtk_Handle; // Not defined here
     //  Dtk_Handle *_Private; // Handle
     enum {
          _typeID = DTK_TYPE_KINEMATIC
     };
 
     Dtk_Kinematic();
 
 
     Dtk_Kinematic(const Dtk_Kinematic& 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:
 
     Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
     { 
          if (inId == _typeID)
          {
               return 1; 
          }
          return Dtk_Entity::DtkDynamicType(inId); 
     }
 
     static Dtk_Kinematic* DtkDynamicCast(Dtk_Object * s)
     { 
          if(s->DtkDynamicType(_typeID)) 
               return static_cast<Dtk_Kinematic*>(s); 
          return NULL; 
     } 
 
     type_detk get_type_detk() const { return DTK_TYPE_KINEMATIC; }
 
     static Dtk_KinematicPtr Create();
 
     Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
 
    static Dtk_KinematicPtr release(Dtk_KinematicPtr inKinematic);
 
    Dtk_status Dump(FILE * inFile, Dtk_bool initXml = 1);
 
    Dtk_bool hasPart(Dtk_KinPartPtr inPart);
    int getPartPosition(Dtk_KinPartPtr inPart);
    int getPartPositionByNumChild(Dtk_KinPartPtr inPart);
    Dtk_KinPartPtr getPartByNumChild(int inNumChild);
    Dtk_KinPartPtr getPart(Dtk_Size_t pos);
    void addPart(Dtk_KinPartPtr inPart);
    Dtk_Size_t getPartSize();
    Dtk_KinPartPtr getPartByInstanceName(Dtk_string & inName);
 
    Dtk_bool hasConstraint(Dtk_KinConstraintPtr inConstraint);
    int getConstraintPosition(Dtk_KinConstraintPtr inConstraint);
    Dtk_KinConstraintPtr getConstraint(Dtk_Size_t pos);
    void addConstraint(Dtk_KinConstraintPtr inConstraint);
    Dtk_Size_t getConstraintSize();
 
    Dtk_bool hasJoint(Dtk_KinJointPtr inJoint);
    int getJointPosition(Dtk_KinJointPtr inJoint);
    Dtk_KinJointPtr getJoint(Dtk_Size_t pos);
    void addJoint(Dtk_KinJointPtr inJoint);
    Dtk_Size_t getJointSize();
 
    Dtk_bool hasCommand(Dtk_KinCommandPtr inCommand);
    int getCommandPosition(Dtk_KinCommandPtr inCommand);
    Dtk_KinCommandPtr getCommand(Dtk_Size_t pos);
    void addCommand(Dtk_KinCommandPtr inCommand);
    Dtk_Size_t getCommandSize();
 
    Dtk_bool hasMechanism(Dtk_KinMechanismPtr inMechanism);
    int getMechanismPosition(Dtk_KinMechanismPtr inMecha);
    Dtk_KinMechanismPtr getMechanism(Dtk_Size_t pos);
    void addMechanism(Dtk_KinMechanismPtr inMechanism);
    Dtk_Size_t getMechanismSize();
    Dtk_KinMechanismPtr getMechanismByCommand(Dtk_KinCommandPtr inCOmmand);
    Dtk_KinMechanismPtr getMechanismByJoint(Dtk_KinJointPtr inJoint);
    Dtk_KinMechanismPtr getMechanismBySpeedAcceleration(Dtk_KinSpeedAccelerationPtr inSpeed);
 
    Dtk_bool hasParameter(Dtk_KinParameterPtr inParameter);
    int getParameterPosition(Dtk_KinParameterPtr inPara);
    Dtk_KinParameterPtr getParameter(Dtk_Size_t pos);
    void addParameter(Dtk_KinParameterPtr inParameter);
    Dtk_Size_t getParameterSize();
 
    void setProduct(Dtk_KinProductPtr inProd);
 
     Dtk_KinProductPtr getProduct();
 
protected:
    Dtk_KinPartTab _parts;
    Dtk_KinConstraintTab _constraints;
    Dtk_KinJointTab _joints;
    Dtk_KinCommandTab _commands;
    Dtk_KinMechanismTab _mechanisms;
    Dtk_KinParameterTab _parameters;
 
    Dtk_KinProductPtr _product;
 
};
 
 
class Dtk_KinFormula : public Dtk_Object
{
 
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_FORMULA
          };
 
          Dtk_KinFormula();
          Dtk_KinFormula(const Dtk_KinFormula & inFormula);
 
          ~Dtk_KinFormula();
 
          friend class Dtk_SmartPtr<Dtk_KinFormula>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinFormula &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinFormula* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinFormula*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_FORMULA; }
 
          static Dtk_KinFormulaPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinFormulaPtr release(Dtk_KinFormulaPtr inFormula);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    Dtk_string getComment();
    void setComment(Dtk_string inComment);
    Dtk_string getFormula();
    void setFormula(Dtk_string inFormula);
    Dtk_string getParam();
    void setParam(Dtk_string inParam);
protected:
    Dtk_string _name;
    int _ID;
 
    Dtk_string _comment;
    Dtk_string _formula;
    Dtk_string _param;
private:
};
 
class Dtk_KinCurve : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_CURVE
          };
 
          Dtk_KinCurve();
          Dtk_KinCurve(const Dtk_KinCurve & inSketch);
 
          ~Dtk_KinCurve();
 
          friend class Dtk_SmartPtr<Dtk_KinCurve>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinCurve &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinCurve* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinCurve*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_CURVE; }
 
          static Dtk_KinCurvePtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinCurvePtr release(Dtk_KinCurvePtr inCurve);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_string getFileName();
    void setFileName(const Dtk_string & inFileName);
    int getIdBlock();
    void setIdBlock(int inId);
    void getEntity(Dtk_Size_t inPos, void ** outEntity, enum type_detk * outType);
    void addEntity(void * inEntity, enum type_detk inType);
    Dtk_Size_t getEntitySize();
protected:
    Dtk_string _fileName;
    int _idBlock;
    Dtk_tab<type_detk> _typeEntity;
    Dtk_tab<void *> _entity;
private:
};
 
 
 
class Dtk_KinLaw : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_LAW
          };
 
          Dtk_KinLaw();
          Dtk_KinLaw(const Dtk_KinLaw& inLaw);
 
          ~Dtk_KinLaw();
 
          friend class Dtk_SmartPtr<Dtk_KinLaw>;
 
     private:
          void _Init();
          void _Copy(const Dtk_KinLaw &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinLaw* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinLaw*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_LAW; }
 
          static Dtk_KinLawPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinLawPtr release(Dtk_KinLawPtr inLaw);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_bool isEqual(Dtk_KinLawPtr inLaw);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
    Dtk_string getComment();
    void setComment(Dtk_string inComment);
    int getSynchrone();
    void setSynchrone(int inSynchrone);
    Dtk_KinFormulaPtr getExpression();
    void setExpression(Dtk_KinFormulaPtr inExpression);
 
    void addCurve(Dtk_KinCurvePtr inCurve);
    Dtk_KinCurvePtr getCurve(Dtk_Size_t inPos);
    Dtk_Size_t getCurveSize();
 
    void addParameter(Dtk_KinParameterPtr param);
    Dtk_KinParameterTab getParameter();
    void setParameter(Dtk_KinParameterTab inParamOut);
    int getActive();
    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;
    int _active;
 
    int _algo;
private:
};
 
class Dtk_KinSpeedAcceleration : public Dtk_Object
{
     protected:
          //  struct Dtk_Handle; // Not defined here
          //  Dtk_Handle *_Private; // Handle
          enum {
               _typeID = DTK_TYPE_KIN_SPEEDACCELERATION
          };
 
          Dtk_KinSpeedAcceleration();
          Dtk_KinSpeedAcceleration(const Dtk_KinSpeedAcceleration& inSpeedAcceleration);
 
          ~Dtk_KinSpeedAcceleration();
 
          friend class Dtk_SmartPtr<Dtk_KinSpeedAcceleration>;
     private:
          void _Init();
          void _Copy(const Dtk_KinSpeedAcceleration &kin);
          void _Reset();
 
     public:
 
          Dtk_Int32 DtkDynamicType(const Dtk_Int32 &inId)
          { 
               if (inId == _typeID)
               {
                    return 1; 
               }
               return Dtk_Object::DtkDynamicType(inId); 
          }
 
          static Dtk_KinSpeedAcceleration* DtkDynamicCast(Dtk_Object * s)
          { 
               if(s->DtkDynamicType(_typeID)) 
                    return static_cast<Dtk_KinSpeedAcceleration*>(s); 
               return NULL; 
          } 
 
          type_detk get_type_detk() const { return DTK_TYPE_KIN_SPEEDACCELERATION; }
 
          static Dtk_KinSpeedAccelerationPtr Create();
 
          Dtk_ErrorStatus Transform(const Dtk_transfo& inTransfo);
 
public:
 
    static Dtk_KinSpeedAccelerationPtr release(Dtk_KinSpeedAccelerationPtr inSpeedAcceleration);
 
    Dtk_status Dump(FILE * inFile);
 
    Dtk_bool operator==(Dtk_KinSpeedAcceleration & inSpeed);
    Dtk_bool isEqual(Dtk_KinSpeedAccelerationPtr inSpeed);
 
    Dtk_string getName();
    void setName(Dtk_string inName);
    int getId();
    void setId(int inId);
 
    Dtk_KinPartPtr getRefProd();
    void setRefProd(Dtk_KinPartPtr inPart);
    Dtk_KinConnectorPtr getPoint();
    void setPoint(Dtk_KinConnectorPtr inPart);
 
    Dtk_KinParameterPtr getPtX();
    void setPtX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getPtY();
    void setPtY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getPtZ();
    void setPtZ(Dtk_KinParameterPtr inParam);
 
    Dtk_KinParameterPtr getLinearSpeedX();
    void setLinearSpeedX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearSpeedY();
    void setLinearSpeedY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearSpeedZ();
    void setLinearSpeedZ(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearSpeed();
    void setLinearSpeed(Dtk_KinParameterPtr inParam);
 
    Dtk_KinParameterPtr getLinearAccelerationX();
    void setLinearAccelerationX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearAccelerationY();
    void setLinearAccelerationY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearAccelerationZ();
    void setLinearAccelerationZ(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getLinearAcceleration();
    void setLinearAcceleration(Dtk_KinParameterPtr inParam);
 
    Dtk_KinParameterPtr getAngularSpeedX();
    void setAngularSpeedX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularSpeedY();
    void setAngularSpeedY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularSpeedZ();
    void setAngularSpeedZ(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularSpeed();
    void setAngularSpeed(Dtk_KinParameterPtr inParam);
 
    Dtk_KinParameterPtr getAngularAccelerationX();
    void setAngularAccelerationX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularAccelerationY();
    void setAngularAccelerationY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularAccelerationZ();
    void setAngularAccelerationZ(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getAngularAcceleration();
    void setAngularAcceleration(Dtk_KinParameterPtr inParam);
 
    Dtk_KinParameterPtr getCirX();
    void setCirX(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getCirY();
    void setCirY(Dtk_KinParameterPtr inParam);
    Dtk_KinParameterPtr getCirZ();
    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
 
    Dtk_KinParameterPtr _pt[3];
    Dtk_KinParameterPtr _linearSpeed[5];
    Dtk_KinParameterPtr _linearAcc[5];
    Dtk_KinParameterPtr _angularSpeed[5];
    Dtk_KinParameterPtr _angularAcc[5];
    Dtk_KinParameterPtr _cir[3];
};
 
#endif