robodk_api.h

// Copyright 2015-2021 - RoboDK Inc. - https://robodk.com/
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// --------------------------------------------
// --------------- DESCRIPTION ----------------
// This file defines the following two classes:
//     Joints : for 1D arrays representing joint values
//     Mat : for pose multiplications
//     RoboDK (Robolink()) : Main interface with RoboDK
//     Item : Represents an item in the RoboDK station
// These classes are the objects used to interact with RoboDK and create macros.
// An item is an object in the RoboDK tree (it can be either a robot, an object, a tool, a frame, a program, ...).
// Items can be retrieved from the RoboDK station using the Robolink() object (such as Robolink.Item() method)
//
// In this document: pose = transformation matrix = homogeneous matrix = 4x4 matrix
//
// More information about the RoboDK API here:
//     https://robodk.com/doc/en/RoboDK-API.html
//     https://robodk.com/doc/en/PythonAPI/index.html
//
// More information about RoboDK post processors here:
//     https://robodk.com/help#PostProcessor
//
// Visit the Matrix and Quaternions FAQ for more information about pose/homogeneous transformations
//     http://www.j3d.org/matrix_faq/matrfaq_latest.html
//
//---------------------------------------------
// TIPS:
//  1- Add #define RDK_SKIP_NAMESPACE
//     to avoid using the RoboDK_API namespace
//  2- Add #define RDK_WITH_EXPORTS  (and RDK_EXPORTS)
//     to generate/import as a DLL
//---------------------------------------------
 
 
#ifndef ROBODK_API_H
#define ROBODK_API_H
 
 
 
#ifdef RDK_WITH_EXPORTS
    #ifdef RDK_EXPORTS
    #define ROBODK __declspec(dllexport)
    #else
    #define ROBODK __declspec(dllimport)
    #endif
#else
    #define ROBODK
#endif
 
 
#include <QtCore/QString>
#include <QtGui/QMatrix4x4> // this should not be part of the QtGui! it is just a matrix
#include <QDebug>
 
 
class QAbstractSocket;
 
 
#ifndef RDK_SKIP_NAMESPACE
 
namespace RoboDK_API {
#endif
 
 
class Item;
class RoboDK;
struct GetPointsResult;
 
 
#define RDK_SIZE_JOINTS_MAX 12
// IMPORTANT!! Do not change this value
 
#define RDK_SIZE_MAX_CONFIG 4
// IMPORTANT!! Do not change this value
 
//typedef double tJoints[RDK_SIZE_JOINTS_MAX];
 
 
typedef double tXYZWPR[6];
 
typedef double tXYZ[3];
 
 
typedef double tConfig[RDK_SIZE_MAX_CONFIG];
 
 
#define DOT(v,q)   ((v)[0]*(q)[0] + (v)[1]*(q)[1] + (v)[2]*(q)[2])
 
#define NORM(v)   (sqrt((v)[0]*(v)[0] + (v)[1]*(v)[1] + (v)[2]*(v)[2]))
 
#define CROSS(out,a,b) \
    (out)[0] = (a)[1]*(b)[2] - (b)[1]*(a)[2]; \
    (out)[1] = (a)[2]*(b)[0] - (b)[2]*(a)[0]; \
    (out)[2] = (a)[0]*(b)[1] - (b)[0]*(a)[1];
 
#define NORMALIZE(inout){\
    double norm;\
    norm = sqrt((inout)[0]*(inout)[0] + (inout)[1]*(inout)[1] + (inout)[2]*(inout)[2]);\
    (inout)[0] = (inout)[0]/norm;\
    (inout)[1] = (inout)[1]/norm;\
    (inout)[2] = (inout)[2]/norm;}
 
 
 
struct Color{
    float r;
 
    float g;
 
    float b;
 
    float a;
};
 
 
 
 
 
 
//------------------------------------------------------------------------------------------------------------
 
 
 
struct tMatrix2D {
    double *data;
 
    int *size;
 
    int allocatedSize;
 
    int numDimensions;
 
    bool canFreeData;
};
 
 
 
 
 
//--------------------- Joints class -----------------------
 
class ROBODK tJoints {
 
public:
    tJoints(int ndofs = 0);
 
    tJoints(const double *joints, int ndofs = 0);
 
    tJoints(const float *joints, int ndofs = 0);
 
    tJoints(const tJoints &jnts);
 
    tJoints(const tMatrix2D *mat2d, int column=0, int ndofs=-1);
 
    tJoints(const QString &str);
 
    operator QString() const { return ToString(); }
 
    const double *ValuesD() const;
 
    const float *ValuesF() const;
 
#ifdef ROBODK_API_FLOATS
    const float *Values() const;
#else
    const double *Values() const;
#endif
 
 
 
 
 
    double *Data();
 
    int Length() const;
 
    void setLength(int new_length);
 
    bool Valid() const;
 
    int GetValues(double *joints);
 
    void SetValues(const double *joints, int ndofs = -1);
 
    void SetValues(const float *joints, int ndofs = -1);
 
    QString ToString(const QString &separator=", ", int precision = 3) const;
 
    bool FromString(const QString &str);
 
 
public:
    int _nDOFs;
 
    double _Values[RDK_SIZE_JOINTS_MAX];
 
    float _ValuesF[RDK_SIZE_JOINTS_MAX];
};
 
 
class ROBODK Mat : public QMatrix4x4 {
 
public:
 
    Mat();
 
    Mat(bool valid);
 
    Mat(const QMatrix4x4 &matrix);
 
    Mat(const Mat &matrix);
 
    Mat(double nx, double ox, double ax, double tx, double ny, double oy, double ay, double ty, double nz, double oz, double az, double tz);
 
    Mat(const double values[16]);
 
    Mat(const float values[16]);
 
    ~Mat();
 
    operator QString() const { return ToString(); }
 
    void setVX(double x, double y, double z);
 
    void setVY(double x, double y, double z);
 
    void setVZ(double x, double y, double z);
 
    void setPos(double x, double y, double z);
 
    void setVX(double xyz[3]);
 
    void setVY(double xyz[3]);
 
    void setVZ(double xyz[3]);
 
    void setPos(double xyz[3]);
 
    void VX(tXYZ xyz) const;
 
    void VY(tXYZ xyz) const;
 
    void VZ(tXYZ xyz) const;
 
    void Pos(tXYZ xyz) const;
 
    void Set(int r, int c, double value);
 
    double Get(int r, int c) const;
 
    Mat inv() const;
 
    bool isHomogeneous() const;
 
    bool MakeHomogeneous();
 
 
 
 
    //------ Pose to xyzrpw and xyzrpw to pose------------
 
    void ToXYZRPW(tXYZWPR xyzwpr) const;
 
    QString ToString(const QString &separator=", ", int precision = 3, bool xyzwpr_only = false) const;
 
    bool FromString(const QString &str);
 
    void FromXYZRPW(tXYZWPR xyzwpr);
 
    static Mat XYZRPW_2_Mat(double x, double y, double z, double r, double p, double w);
    static Mat XYZRPW_2_Mat(tXYZWPR xyzwpr);
 
    const double* ValuesD() const;
 
    const float* ValuesF() const;
 
#ifdef ROBODK_API_FLOATS
    const float* Values() const;
#else
    const double* Values() const;
#endif
 
    void Values(double values[16]) const;
 
    void Values(float values[16]) const;
 
    bool Valid() const;
 
    static Mat transl(double x, double y, double z);
 
    static Mat rotx(double rx);
 
    static Mat roty(double ry);
 
    static Mat rotz(double rz);
 
 
private:
    bool _valid;
 
// this is a dummy variable to easily obtain a pointer to a 16-double-array for matrix multiplications
private:
    double _ddata16[16];
 
};
 
class ROBODK RoboDK {
    friend class RoboDK_API::Item;
 
public:
    explicit RoboDK(QAbstractSocket *socket, bool fUseExceptions = false);
    RoboDK(const QString &robodk_ip="", int com_port=-1, const QString &args="", const QString &path="", bool fUseExceptions = false);
    ~RoboDK();
 
    quint64 ProcessID();
    quint64 WindowID();
 
    bool Connected();
    bool Connect();
 
    void Disconnect();
    void Finish();
 
 
    Item getItem(QString name, int itemtype = -1);
 
    QStringList getItemListNames(int filter = -1);
 
    QList<Item> getItemList(int filter = -1);
 
    Item ItemUserPick(const QString &message = "Pick one item", int itemtype = -1);
 
    void ShowRoboDK();
 
    void HideRoboDK();
 
    void CloseRoboDK();
 
    QString Version();
 
    void setWindowState(int windowstate = WINDOWSTATE_NORMAL);
 
    void setFlagsRoboDK(int flags = FLAG_ROBODK_ALL);
 
    void setFlagsItem(Item item, int flags = FLAG_ITEM_ALL);
 
    int getFlagsItem(Item item);
 
    void ShowMessage(const QString &message, bool popup = true);
 
    void Copy(const Item &tocopy);
 
    Item Paste(const Item *paste_to=nullptr);
 
    Item AddFile(const QString &filename, const Item *parent=nullptr);
 
    void Save(const QString &filename, const Item *itemsave=nullptr);
 
    Item AddShape(tMatrix2D *trianglePoints,Item *addTo = nullptr, bool shapeOverride = false, Color *color = nullptr);
 
    Item AddCurve(tMatrix2D *curvePoints,Item *referenceObject = nullptr,bool addToRef = false,int ProjectionType = PROJECTION_ALONG_NORMAL_RECALC);
 
    Item AddPoints(tMatrix2D *points, Item *referenceObject = nullptr, bool addToRef = false, int ProjectionType =  PROJECTION_ALONG_NORMAL_RECALC);
 
    void ProjectPoints(tMatrix2D *points, tMatrix2D **projected, Item objectProject, int ProjectionType = PROJECTION_ALONG_NORMAL_RECALC);
 
    void CloseStation();
 
    Item AddTarget(const QString &name, Item *itemparent = nullptr, Item *itemrobot = nullptr);
 
    Item AddFrame(const QString &name, Item *itemparent = nullptr);
 
    Item AddProgram(const QString &name, Item *itemrobot = nullptr);
 
    Item AddStation(const QString &name);
 
    Item AddMachiningProject(const QString &name = "Curve follow settings",Item *itemrobot = nullptr);
 
    QList<Item> getOpenStation();
 
    void setActiveStation(Item stn);
 
    Item getActiveStation();
 
    int RunProgram(const QString &function_w_params);
 
    int RunCode(const QString &code, bool code_is_fcn_call = false);
 
    void RunMessage(const QString &message, bool message_is_comment = false);
 
    void Render(bool always_render = false);
 
    void Update();
 
    bool IsInside(Item object_inside, Item object_parent);
 
    int setCollisionActive(int check_state = COLLISION_ON);
 
    bool setCollisionActivePair(int check_state, Item item1, Item item2, int id1 = 0, int id2 = 0);
 
    int Collisions();
 
    int Collision(Item item1, Item item2);
 
    QList<Item> getCollisionItems(QList<int> link_id_list);
 
    void setSimulationSpeed(double speed);
 
    double SimulationSpeed();
 
    void setRunMode(int run_mode = 1);
 
    int RunMode();
 
    QList<QPair<QString, QString> > getParams();
 
    QString getParam(const QString &param);
 
    void setParam(const QString &param, const QString &value);
 
    QString Command(const QString &cmd, const QString &value="");
 
    // --- add calibrate reference, calibrate tool, measure tracker, etc...
 
    bool LaserTrackerMeasure(tXYZ xyz, tXYZ estimate, bool search = false);
 
    bool CollisionLine(tXYZ p1, tXYZ p2);
 
    void setVisible(QList<Item> itemList, QList<bool> visibleList, QList<int> visibleFrames);
 
    void ShowAsCollided(QList<Item> itemList, QList<bool> collidedList, QList<int> *robot_link_id = nullptr);
 
    void CalibrateTool(tMatrix2D *poses_joints, tXYZ tcp_xyz, int format=EULER_RX_RY_RZ, int algorithm=CALIBRATE_TCP_BY_POINT, Item *robot=nullptr, double *error_stats=nullptr);
 
    Mat CalibrateReference(tMatrix2D *poses_joints, int method = CALIBRATE_FRAME_3P_P1_ON_X, bool use_joints = false, Item *robot = nullptr);
 
    int ProgramStart(const QString &progname, const QString &defaultfolder = "", const QString &postprocessor = "", Item *robot = nullptr);
 
    void setViewPose(const Mat &pose);
 
    Mat ViewPose();
 
    Item Cam2D_Add(const Item &item_object, const QString &cam_params, const Item *cam_item=nullptr);
 
    int Cam2D_Snapshot(const QString &file_save_img, const Item &cam_item, const QString &params="");
 
     int Cam2D_SetParams(const QString &cam_params, const Item &cam_item);
 
    bool setRobotParams(Item *robot,tMatrix2D dhm, Mat poseBase, Mat poseTool);
 
    Item getCursorXYZ(int x = -1, int y = -1, tXYZ xyzStation = nullptr);
 
    GetPointsResult GetPoints(int featureType = FEATURE_HOVER_OBJECT_MESH);
 
    QString License();
 
    QList<Item> Selection();
 
    void setSelection(QList<Item> list_items);
    
    void PluginLoad(const QString &pluginName, int load=1); 
    
    QString PluginCommand(const QString &pluginName, const QString &pluginCommand, const QString &pluginValue="");
 
    Item Popup_ISO9283_CubeProgram(Item *robot=nullptr, tXYZ center=nullptr, double side=-1, bool blocking=true);
 
    bool FileSet(const QString &file_local, const QString &file_remote="", bool load_file=true, Item *attach_to=nullptr);
 
    bool FileGet(const QString &path_file_local, Item *station=nullptr, const QString path_file_remote="");
 
    bool EmbedWindow(QString window_name, QString docked_name="", int size_w=-1, int size_h=-1, quint64 pid=0, int area_add=1, int area_allowed=15, int timeout=500);
 
    bool EventsListen();
    bool WaitForEvent(int &evt,Item &itm);
    bool Event_Receive_3D_POS(double *data, int *valueCount);
    bool Event_Receive_Mouse_data(int *data);
    bool Event_Receive_Event_Moved(Mat *pose_rel_out);
    bool Event_Connected();
 
public:
 
 
    enum {
        ITEM_TYPE_ANY = -1,
 
        ITEM_TYPE_STATION = 1,
 
        ITEM_TYPE_ROBOT = 2,
 
        ITEM_TYPE_FRAME = 3,
 
        ITEM_TYPE_TOOL = 4,
 
        ITEM_TYPE_OBJECT = 5,
 
        ITEM_TYPE_TARGET = 6,
 
        ITEM_TYPE_PROGRAM = 8,
 
        ITEM_TYPE_INSTRUCTION = 9,
 
        ITEM_TYPE_PROGRAM_PYTHON = 10,
 
        ITEM_TYPE_MACHINING = 11,
 
        ITEM_TYPE_BALLBARVALIDATION = 12,
 
        ITEM_TYPE_CALIBPROJECT = 13,
 
        ITEM_TYPE_VALID_ISO9283 = 14
    };
 
    enum {
        INS_TYPE_INVALID = -1,
 
        INS_TYPE_MOVE = 0,
 
        INS_TYPE_MOVEC = 1,
 
        INS_TYPE_CHANGESPEED = 2,
 
        INS_TYPE_CHANGEFRAME = 3,
 
        INS_TYPE_CHANGETOOL = 4,
 
        INS_TYPE_CHANGEROBOT = 5,
 
        INS_TYPE_PAUSE = 6,
 
        INS_TYPE_EVENT = 7,
 
        INS_TYPE_CODE = 8,
 
        INS_TYPE_PRINT = 9
    };
 
    enum {
        MOVE_TYPE_INVALID = -1,
 
        MOVE_TYPE_JOINT = 1,
 
        MOVE_TYPE_LINEAR = 2,
 
        MOVE_TYPE_CIRCULAR = 3
    };
 
    enum {
        RUNMODE_SIMULATE = 1,
 
        RUNMODE_QUICKVALIDATE = 2,
 
        RUNMODE_MAKE_ROBOTPROG = 3,
 
        RUNMODE_MAKE_ROBOTPROG_AND_UPLOAD = 4,
 
        RUNMODE_MAKE_ROBOTPROG_AND_START = 5,
 
        RUNMODE_RUN_ROBOT = 6
    };
 
    enum {
        PROGRAM_RUN_ON_SIMULATOR = 1,
 
        PROGRAM_RUN_ON_ROBOT = 2
    };
 
    enum {
 
        CALIBRATE_TCP_BY_POINT = 0,
 
        CALIBRATE_TCP_BY_PLANE = 1
    };
 
    enum {
        CALIBRATE_FRAME_3P_P1_ON_X = 0,
 
        CALIBRATE_FRAME_3P_P1_ORIGIN = 1,
 
        CALIBRATE_FRAME_6P = 2,
 
        CALIBRATE_TURNTABLE = 3
    };
 
    enum {
        PROJECTION_NONE                = 0,
 
        PROJECTION_CLOSEST             = 1,
 
        PROJECTION_ALONG_NORMAL        = 2,
 
        PROJECTION_ALONG_NORMAL_RECALC = 3,
 
        PROJECTION_CLOSEST_RECALC      = 4,
 
        PROJECTION_RECALC              = 5
    };
 
    enum {
 
        JOINT_FORMAT      = -1,
 
        EULER_RX_RYp_RZpp = 0,
 
        EULER_RZ_RYp_RXpp = 1,
 
        EULER_RZ_RYp_RZpp = 2,
 
        EULER_RZ_RXp_RZpp = 3,
 
        EULER_RX_RY_RZ    = 4,
 
        EULER_RZ_RY_RX    = 5,
 
        EULER_QUEATERNION = 6
    };
 
    enum {
 
        WINDOWSTATE_HIDDEN = -1,
 
        WINDOWSTATE_SHOW = 0,
 
        WINDOWSTATE_MINIMIZED = 1,
 
        WINDOWSTATE_NORMAL = 2,
 
        WINDOWSTATE_MAXIMIZED = 3,
 
        WINDOWSTATE_FULLSCREEN = 4,
 
        WINDOWSTATE_CINEMA = 5,
 
        WINDOWSTATE_FULLSCREEN_CINEMA = 6
    };
 
    enum {
        INSTRUCTION_CALL_PROGRAM = 0,
 
        INSTRUCTION_INSERT_CODE = 1,
 
        INSTRUCTION_START_THREAD = 2,
 
        INSTRUCTION_COMMENT = 3,
 
        INSTRUCTION_SHOW_MESSAGE = 4
    };
 
    enum {
        FEATURE_NONE = 0,
 
        FEATURE_SURFACE = 1,
 
        FEATURE_CURVE = 2,
 
        FEATURE_POINT = 3,
 
        FEATURE_OBJECT_MESH = 7,
 
        FEATURE_SURFACE_PREVIEW = 8,
 
        FEATURE_MESH = 9,
 
        // The following do not require providing an object
 
        FEATURE_HOVER_OBJECT_MESH = 10,
 
        FEATURE_HOVER_OBJECT = 11
    };
 
    enum {
        SPRAY_OFF = 0,
        SPRAY_ON = 1
    };
 
    enum {
        COLLISION_OFF = 0,
 
        COLLISION_ON = 1
    };
 
    // Event types
    enum {
        EVENT_SELECTION_TREE_CHANGED = 1,
        EVENT_ITEM_MOVED = 2, // obsolete after RoboDK 4.2.0. Use EVENT_ITEM_MOVED_POSE instead
        EVENT_REFERENCE_PICKED = 3,
        EVENT_REFERENCE_RELEASED = 4,
        EVENT_TOOL_MODIFIED = 5,
        EVENT_CREATED_ISOCUBE = 6,
        EVENT_SELECTION_3D_CHANGED = 7,
        EVENT_3DVIEW_MOVED = 8,
        EVENT_ROBOT_MOVED = 9,
        EVENT_KEY = 10,
        EVENT_ITEM_MOVED_POSE = 11
    };
 
 
    enum {
        FLAG_ROBODK_TREE_ACTIVE = 1,
 
        FLAG_ROBODK_3DVIEW_ACTIVE = 2,
 
        FLAG_ROBODK_LEFT_CLICK = 4,
 
        FLAG_ROBODK_RIGHT_CLICK = 8,
 
        FLAG_ROBODK_DOUBLE_CLICK = 16,
 
        FLAG_ROBODK_MENU_ACTIVE = 32,
 
        FLAG_ROBODK_MENUFILE_ACTIVE = 64,
 
        FLAG_ROBODK_MENUEDIT_ACTIVE = 128,
 
        FLAG_ROBODK_MENUPROGRAM_ACTIVE = 256,
 
        FLAG_ROBODK_MENUTOOLS_ACTIVE = 512,
 
        FLAG_ROBODK_MENUUTILITIES_ACTIVE = 1024,
 
        FLAG_ROBODK_MENUCONNECT_ACTIVE = 2048,
 
        FLAG_ROBODK_WINDOWKEYS_ACTIVE = 4096,
 
        FLAG_ROBODK_NONE = 0,
 
        FLAG_ROBODK_ALL = 0xFFFF,
 
        FLAG_ROBODK_MENU_ACTIVE_ALL = FLAG_ROBODK_MENU_ACTIVE | FLAG_ROBODK_MENUFILE_ACTIVE | FLAG_ROBODK_MENUEDIT_ACTIVE | FLAG_ROBODK_MENUPROGRAM_ACTIVE | FLAG_ROBODK_MENUTOOLS_ACTIVE | FLAG_ROBODK_MENUUTILITIES_ACTIVE | FLAG_ROBODK_MENUCONNECT_ACTIVE
    };
 
    enum {
        FLAG_ITEM_SELECTABLE = 1,
 
        FLAG_ITEM_EDITABLE = 2,
 
        FLAG_ITEM_DRAGALLOWED = 4,
 
        FLAG_ITEM_DROPALLOWED = 8,
 
        FLAG_ITEM_ENABLED = 32,
 
        FLAG_ITEM_AUTOTRISTATE = 64,
 
        FLAG_ITEM_NOCHILDREN = 128,
        FLAG_ITEM_USERTRISTATE = 256,
 
        FLAG_ITEM_NONE = 0,
 
        FLAG_ITEM_ALL = 64 + 32 + 8 + 4 + 2 + 1
    };
 
private:
    QAbstractSocket *_COM;
    bool _USE_EXCPETIONS;
    bool _OWN_SOCKET;
    QAbstractSocket *_COM_EVT;
    QString _IP;
    int _PORT;
    int _TIMEOUT;
    qint64 _PROCESS;
 
    QString _ROBODK_BIN; // file path to the robodk program (executable), typically C:/RoboDK/bin/RoboDK.exe. Leave empty to use the registry key: HKEY_LOCAL_MACHINE\SOFTWARE\RoboDK
    QString _ARGUMENTS;       // arguments to provide to RoboDK on startup
 
    bool _connected();
    bool _connect();
    bool _connect_smart(); // will attempt to start RoboDK
    void _disconnect();
 
    bool _check_connection();
    bool _check_status();
 
    bool _waitline(QAbstractSocket *com = nullptr);
    QString _recv_Line(QAbstractSocket *com = nullptr);//QString &string);
    bool _send_Line(const QString &string,QAbstractSocket *com = nullptr);
    int _recv_Int(QAbstractSocket *com = nullptr);//qint32 &value);
    bool _send_Int(const qint32 value,QAbstractSocket *com = nullptr);
    Item _recv_Item(QAbstractSocket *com = nullptr);//Item *item);
    bool _send_Item(const Item *item);
    bool _send_Item(const Item &item);
    Mat _recv_Pose(QAbstractSocket *com = nullptr);//Mat &pose);
    bool _send_Pose(const Mat &pose);
    bool _recv_XYZ(tXYZ pos);
    bool _send_XYZ(const tXYZ pos);
    bool _recv_Array(double *values, int *psize=nullptr,QAbstractSocket *com = nullptr);
    bool _send_Array(const double *values, int nvalues);
    bool _recv_Array(tJoints *jnts);
    bool _send_Array(const tJoints *jnts);
    bool _send_Array(const Mat *mat);
    bool _recv_Matrix2D(tMatrix2D **mat);
    bool _send_Matrix2D(tMatrix2D *mat);
    bool _send_Bytes(const QByteArray &data, QAbstractSocket *com = nullptr);
    QByteArray _recv_Bytes(QAbstractSocket *com = nullptr);
 
 
    void _moveX(const Item *target, const tJoints *joints, const Mat *mat_target, const Item *itemrobot, int movetype, bool blocking);
    void _moveC(const Item *target1, const tJoints *joints1, const Mat *mat_target1, const Item *target2, const tJoints *joints2, const Mat *mat_target2, const Item *itemrobot, bool blocking);
};
 
 
class ROBODK Item {
    friend class RoboDK_API::RoboDK;
 
public:
    Item(RoboDK *rdk=nullptr, quint64 ptr=0, qint32 type=-1);
    Item(const Item &other);
    Item& operator=( const Item& x ) = default;
 
    ~Item();
 
    QString ToString() const;
 
    RoboDK* RDK();
 
    void NewLink();
 
    int Type() const;
 
    void Save(const QString &filename);
 
    void Delete();
 
    bool Valid(bool check_pointer=false) const ;
 
    void setParent(Item parent);
 
    void setParentStatic(Item parent);
 
    Item AttachClosest();
 
    Item DetachClosest(Item parent);
 
    void DetachAll(Item parent);
 
    Item Parent() const;
 
    QList<Item> Childs() const;
 
    bool Visible() const;
 
    void setVisible(bool visible, int visible_frame = -1);
 
    QString Name() const;
 
    void setName(const QString &name);
 
    void setPose(const Mat pose);
 
    Mat Pose() const;
 
    void setGeometryPose(const Mat pose);
 
    Mat GeometryPose();
 
    /*/// <summary>
    void setHtool(Mat pose);
    */
 
    /*
    Mat Htool();
    */
 
    Mat PoseTool();
 
    Mat PoseFrame();
 
    void setPoseFrame(const Mat frame_pose);
 
    void setPoseFrame(const Item frame_item);
 
    void setPoseTool(const Mat tool_pose);
 
    void setPoseTool(const Item tool_item);
 
    void setPoseAbs(const Mat pose);
 
    Mat PoseAbs();
 
    void setColor(double colorRGBA[4]);
 
 
 
//---------- add more
 
    void Scale(double scale);
 
    void Scale(double scale_xyz[3]);
 
 
    GetPointsResult GetPoints(int featureType = RoboDK::FEATURE_SURFACE, int featureId = 0);
 
    bool SelectedFeature(int &featureType, int &featureId);
 
    Item setMachiningParameters(QString ncfile = "", Item part_obj = nullptr, QString options = "");
 
    void setAsCartesianTarget();
 
    void setAsJointTarget();
 
    bool isJointTarget() const ;
 
    tJoints Joints() const ;
 
    tJoints JointsHome() const;
 
    void setJointsHome(const tJoints &jnts);
 
    Item ObjectLink(int link_id = 0);
 
    Item getLink(int type_linked = RoboDK::ITEM_TYPE_ROBOT);
 
    void setJoints(const tJoints &jnts);
 
    void JointLimits(tJoints *lower_limits, tJoints *upper_limits);
 
    void setJointLimits(const tJoints &lower_limits, const tJoints &upper_limits);
 
    void setRobot(const Item &robot);
 
    Item AddTool(const Mat &tool_pose, const QString &tool_name = "New TCP");
 
    Mat SolveFK(const tJoints &joints, const Mat *tool = nullptr, const Mat *ref = nullptr);
 
    void JointsConfig(const tJoints &joints, tConfig config);
 
    tJoints SolveIK(const Mat &pose, const Mat *tool=nullptr, const Mat *ref=nullptr);
 
    tJoints SolveIK(const Mat pose, tJoints joints_approx, const Mat *tool = nullptr, const Mat *ref = nullptr);
 
    tMatrix2D *SolveIK_All_Mat2D(const Mat &pose, const Mat *tool=nullptr, const Mat *ref=nullptr);
 
    QList<tJoints> SolveIK_All(const Mat &pose, const Mat *tool=nullptr, const Mat *ref=nullptr);
 
    bool Connect(const QString &robot_ip = "");
 
    bool Disconnect();
 
    void MoveJ(const Item &itemtarget, bool blocking = true);
 
    void MoveJ(const tJoints &joints, bool blocking = true);
 
    void MoveJ(const Mat &target, bool blocking = true);
 
    void MoveL(const Item &itemtarget, bool blocking = true);
 
    void MoveL(const tJoints &joints, bool blocking = true);
 
    void MoveL(const Mat &target, bool blocking = true);
 
    void MoveC(const Item &itemtarget1, const Item &itemtarget2, bool blocking = true);
 
    void MoveC(const tJoints &joints1, const tJoints &joints2, bool blocking = true);
 
    void MoveC(const Mat &target1, const Mat &target2, bool blocking = true);
 
    int MoveJ_Test(const tJoints &j1, const tJoints &j2, double minstep_deg = -1);
 
    int MoveL_Test(const tJoints &joints1, const Mat &pose2, double minstep_mm = -1);
 
    void setSpeed(double speed_linear, double accel_linear = -1, double speed_joints = -1, double accel_joints = -1);
 
    void setRounding(double zonedata);
 
    void ShowSequence(tMatrix2D *sequence);
 
    bool Busy();
 
    void Stop();
 
    void WaitMove(double timeout_sec = 300) const;
 
    void setAccuracyActive(int accurate = 1);
 
    bool MakeProgram(const QString &filename);
 
    void setRunType(int program_run_type);
 
    int RunProgram();
 
    int RunCode(const QString &parameters);
 
    int RunInstruction(const QString &code, int run_type = RoboDK::INSTRUCTION_CALL_PROGRAM);
 
    void Pause(double time_ms = -1);
 
    void setDO(const QString &io_var, const QString &io_value);
 
    void setAO(const QString &io_var, const QString &io_value);
 
    QString getDI(const QString &io_var);
 
 
    QString getAI(const QString &io_var);
 
    void waitDI(const QString &io_var, const QString &io_value, double timeout_ms = -1);
 
    void customInstruction(const QString &name, const QString &path_run, const QString &path_icon = "", bool blocking = true, const QString &cmd_run_on_robot = "");
 
 
    //void addMoveJ(const Item &itemtarget);
    //void addMoveL(const Item &itemtarget);
 
    void ShowInstructions(bool visible=true);
 
    void ShowTargets(bool visible=true);
 
    int InstructionCount();
 
    void Instruction(int ins_id, QString &name, int &instype, int &movetype, bool &isjointtarget, Mat &target, tJoints &joints);
 
    void setInstruction(int ins_id, const QString &name, int instype, int movetype, bool isjointtarget, const Mat &target, const tJoints &joints);
 
    int InstructionList(tMatrix2D *instructions);
 
    double Update(int collision_check = RoboDK::COLLISION_OFF, int timeout_sec = 3600, double *out_nins_time_dist = nullptr, double mm_step = -1, double deg_step = -1);
 
    int InstructionListJoints(QString &error_msg, tMatrix2D **joint_list, double mm_step = 10.0, double deg_step = 5.0, const QString &save_to_file = "", bool collision_check=false, int flags=0, double time_step_s=0.1);
 
 
    QString setParam(const QString &param, const QString &value);
 
    void setParam(const QString &param, const QByteArray &value);
 
    QByteArray getParam(const QString &param);
 
    bool Finish();
 
 
    quint64 GetID();
 
 
private:
    RoboDK *_RDK;
 
    quint64 _PTR;
 
    qint32 _TYPE;
};
 
 
struct GetPointsResult
{
    Item item;
    int featureType;
    int featureId;
    QString featureName;
    tMatrix2D* points;
};
 
 
 
ROBODK Mat transl(double x, double y, double z);
 
ROBODK Mat rotx(double rx);
 
ROBODK Mat roty(double ry);
 
ROBODK Mat rotz(double rz);
 
 
ROBODK tMatrix2D* Matrix2D_Create();
 
ROBODK void Matrix2D_Delete(tMatrix2D **mat);
 
ROBODK void Matrix2D_Set_Size(tMatrix2D *mat, int rows, int cols);
 
ROBODK int Matrix2D_Size(const tMatrix2D *mat, int dim);
 
ROBODK int Matrix2D_Get_ncols(const tMatrix2D *var);
 
ROBODK int Matrix2D_Get_nrows(const tMatrix2D *var);
 
ROBODK double Matrix2D_Get_ij(const tMatrix2D *var, int i, int j);
 
ROBODK double* Matrix2D_Get_col(const tMatrix2D *var, int col);
 
ROBODK void Debug_Array(const double *array, int arraysize);
 
ROBODK void Debug_Matrix2D(const tMatrix2D *mat);
 
 
//ROBODK void Debug_Mat(Mat pose, char show_full_pose);
 
 
 
 
//QDataStream &operator<<(QDataStream &data, const QMatrix4x4 &);
inline QDebug operator<<(QDebug dbg, const Mat &m){ return dbg.noquote() << m.ToString(); }
inline QDebug operator<<(QDebug dbg, const tJoints &jnts){ return dbg.noquote() << jnts.ToString(); }
inline QDebug operator<<(QDebug dbg, const Item &itm){ return dbg.noquote() << itm.ToString(); }
 
inline QDebug operator<<(QDebug dbg, const Mat *m){ return dbg.noquote() << (m == nullptr ? "Mat(null)" : m->ToString()); }
inline QDebug operator<<(QDebug dbg, const tJoints *jnts){ return dbg.noquote() << (jnts == nullptr ? "tJoints(null)" : jnts->ToString()); }
inline QDebug operator<<(QDebug dbg, const Item *itm){ return dbg.noquote() << (itm == nullptr ? "Item(null)" : itm->ToString()); }
 
 
#ifndef RDK_SKIP_NAMESPACE
}
 
#endif
 
 
 
 
#endif // ROBODK_API