mujincontrollerclient.h

説明を見る。

// -*- coding: utf-8 -*-
// Copyright (C) 2012-2013 MUJIN Inc. <rosen.diankov@mujin.co.jp>
//
// 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.
#ifndef MUJIN_CONTROLLERCLIENT_H
#define MUJIN_CONTROLLERCLIENT_H

#ifndef MUJINCLIENT_DISABLE_ASSERT_HANDLER
#define BOOST_ENABLE_ASSERT_HANDLER
#endif

#ifdef _MSC_VER

#pragma warning(disable:4251) // needs to have dll-interface to be used by clients of class
#pragma warning(disable:4190) // C-linkage specified, but returns UDT 'boost::shared_ptr<T>' which is incompatible with C
#pragma warning(disable:4819) //The file contains a character that cannot be represented in the current code page (932). Save the file in Unicode format to prevent data loss using native typeof

#ifndef __PRETTY_FUNCTION__
#define __PRETTY_FUNCTION__ __FUNCDNAME__
#endif

#else
#endif

#if defined(__GNUC__)
#define MUJINCLIENT_DEPRECATED __attribute__((deprecated))
#else
#define MUJINCLIENT_DEPRECATED
#endif

#include <string>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <string>
#include <exception>

#include <iomanip>
#include <fstream>
#include <sstream>

#include <boost/version.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/format.hpp>
#include <boost/array.hpp>
#include <boost/property_tree/ptree.hpp>

namespace mujinclient {

#include <mujincontrollerclient/config.h>

enum MujinErrorCode {
    MEC_Failed=0,
    MEC_InvalidArguments=1, 
    MEC_CommandNotSupported=3, 
    MEC_Assert=4,
    MEC_NotInitialized=9, 
    MEC_InvalidState=10, 
    MEC_Timeout=11, 
    MEC_HTTPClient=12, 
    MEC_HTTPServer=13, 
    MEC_UserAuthentication=14, 
    MEC_AlreadyExists=15, 
    MEC_BinPickingError=16, 
    MEC_HandEyeCalibrationError=17, 
    MEC_ZMQNoResponse=20 
};

enum TaskResourceOptions
{
    TRO_EnableZMQ=1, 
};

inline const char* GetErrorCodeString(MujinErrorCode error)
{
    switch(error) {
    case MEC_Failed: return "Failed";
    case MEC_InvalidArguments: return "InvalidArguments";
    case MEC_CommandNotSupported: return "CommandNotSupported";
    case MEC_Assert: return "Assert";
    case MEC_NotInitialized: return "NotInitialized";
    case MEC_InvalidState: return "InvalidState";
    case MEC_Timeout: return "Timeout";
    case MEC_HTTPClient: return "HTTPClient";
    case MEC_HTTPServer: return "HTTPServer";
    case MEC_UserAuthentication: return "UserAuthentication";
    case MEC_AlreadyExists: return "AlreadyExists";
    case MEC_BinPickingError: return "BinPickingError";
    case MEC_HandEyeCalibrationError: return "HandEyeCalibrationError";
    case MEC_ZMQNoResponse: return "NoResponse";
    }
    // should throw an exception?
    return "";
}

class MUJINCLIENT_API MujinException : public std::exception
{
public:
    MujinException() : std::exception(), _s("unknown exception"), _error(MEC_Failed) {
    }
    MujinException(const std::string& s, MujinErrorCode error=MEC_Failed) : std::exception() {
        _error = error;
        _s = "mujin (";
        _s += GetErrorCodeString(_error);
        _s += "): ";
        _s += s;
    }
    virtual ~MujinException() throw() {
    }
    char const* what() const throw() {
        return _s.c_str();
    }
    const std::string& message() const {
        return _s;
    }
    MujinErrorCode GetCode() const {
        return _error;
    }
private:
    std::string _s;
    MujinErrorCode _error;
};

class ControllerClient;
class ObjectResource;
class RobotResource;
class SceneResource;
class TaskResource;
class BinPickingTaskResource;
class OptimizationResource;
class PlanningResultResource;
class BinPickingResultResource;

typedef boost::shared_ptr<ControllerClient> ControllerClientPtr;
typedef boost::weak_ptr<ControllerClient> ControllerClientWeakPtr;
typedef boost::shared_ptr<ObjectResource> ObjectResourcePtr;
typedef boost::weak_ptr<ObjectResource> ObjectResourceWeakPtr;
typedef boost::shared_ptr<RobotResource> RobotResourcePtr;
typedef boost::weak_ptr<RobotResource> RobotResourceWeakPtr;
typedef boost::shared_ptr<SceneResource> SceneResourcePtr;
typedef boost::weak_ptr<SceneResource> SceneResourceWeakPtr;
typedef boost::shared_ptr<TaskResource> TaskResourcePtr;
typedef boost::weak_ptr<TaskResource> TaskResourceWeakPtr;
typedef boost::shared_ptr<BinPickingTaskResource> BinPickingTaskResourcePtr;
typedef boost::weak_ptr<BinPickingTaskResource> BinPickingTaskResourceWeakPtr;
typedef boost::shared_ptr<OptimizationResource> OptimizationResourcePtr;
typedef boost::weak_ptr<OptimizationResource> OptimizationResourceWeakPtr;
typedef boost::shared_ptr<PlanningResultResource> PlanningResultResourcePtr;
typedef boost::weak_ptr<PlanningResultResource> PlanningResultResourceWeakPtr;
typedef boost::shared_ptr<BinPickingResultResource> BinPickingResultResourcePtr;
typedef boost::weak_ptr<BinPickingResultResource> BinPickingResultResourceWeakPtr;
typedef double Real;

enum JobStatusCode {
    JSC_Pending         = 0, 
    JSC_Active          = 1, 
    JSC_Preempted       = 2, 
    JSC_Succeeded       = 3, 
    JSC_Aborted         = 4, 
    JSC_Rejected        = 5, 
    JSC_Preempting      = 6, 
    JSC_Recalling       = 7, 
    JSC_Recalled        = 8, 
    JSC_Lost            = 9, 
    JSC_Unknown = 0xffffffff, 
};

struct JobStatus
{
    JobStatus() : code(JSC_Unknown) {
    }
    JobStatusCode code; 
    std::string type; 
    std::string message; 
    double elapsedtime; 
    std::string pk; 
};

struct Transform
{
    Transform() {
        quaternion[0] = 1; quaternion[1] = 0; quaternion[2] = 0; quaternion[3] = 0;
        translate[0] = 0; translate[1] = 0; translate[2] = 0;
    }
    Real quaternion[4]; 
    Real translate[3]; 
};

struct InstanceObjectState
{
    Transform transform; 
    std::vector<Real> dofvalues; 
};

typedef std::map<std::string, InstanceObjectState> EnvironmentState;

struct SceneInformation
{
    std::string pk; 
    std::string uri; 
    std::string datemodified; 
    std::string name;
};

class ITLPlanningTaskParameters
{
public:
    ITLPlanningTaskParameters() {
        SetDefaults();
    }
    virtual void SetDefaults() {
        startfromcurrent = 0;
        returnmode = "start";
        vrcruns = 1;
        ignorefigure = 1;
        unit = "mm";
        optimizationvalue = 1;
        program.clear();
    }
    
    int startfromcurrent; 

    std::string returnmode;
    
    int vrcruns; 
    int ignorefigure; 
    std::string unit; 
    Real optimizationvalue; 
    std::string program; 

    EnvironmentState initial_envstate; 
    EnvironmentState final_envstate;  
};

class DensoWaveWincapsTaskParameters : public ITLPlanningTaskParameters
{
public:
    DensoWaveWincapsTaskParameters() : ITLPlanningTaskParameters() {
        SetDefaults();
    }
    void SetDefaults() {
        ITLPlanningTaskParameters::SetDefaults();
        preservespeedparameters = 0;
    }
    int preservespeedparameters; 
};

struct RobotPlacementOptimizationParameters
{
    RobotPlacementOptimizationParameters() {
        SetDefaults();
    }
    inline void SetDefaults() {
        unit = "mm";
        topstorecandidates = 20;
        targetname.clear();
        framename.clear();
        minrange[0] = -400; minrange[1] = -400; minrange[2] = 0; minrange[3] = -180;
        maxrange[0] = 400; maxrange[1] = 400; maxrange[2] = 400; maxrange[3] = 90;
        stepsize[0] = 100; stepsize[1] = 100; stepsize[2] = 100; stepsize[3] = 90;
        ignorebasecollision = 0;
    }
    std::string targetname; 
    std::string framename; 
    Real maxrange[4]; 
    Real minrange[4]; 
    Real stepsize[4]; 
    int ignorebasecollision; 

    std::string unit; 
    int topstorecandidates; 
};

struct PlacementsOptimizationParameters
{
    PlacementsOptimizationParameters() {
        SetDefaults();
    }
    inline void SetDefaults() {
        unit = "mm";
        topstorecandidates = 20;
        for(size_t itarget = 0; itarget < targetnames.size(); ++itarget) {
            targetnames[itarget].clear();
            framenames[itarget].clear();
            ignorebasecollisions[itarget] = 0;
        }
        minranges[0][0] = -400; minranges[0][1] = -400; minranges[0][2] = 0; minranges[0][3] = -180;
        maxranges[0][0] = 400; maxranges[0][1] = 400; maxranges[0][2] = 400; maxranges[0][3] = 90;
        stepsizes[0][0] = 100; stepsizes[0][1] = 100; stepsizes[0][2] = 100; stepsizes[0][3] = 90;
        minranges[1][0] = -100; minranges[1][1] = -100; minranges[1][2] = 0; minranges[1][3] = 0;
        maxranges[1][0] = 100; maxranges[1][1] = 100; maxranges[1][2] = 100; maxranges[1][3] = 0;
        stepsizes[1][0] = 100; stepsizes[1][1] = 100; stepsizes[1][2] = 100; stepsizes[1][3] = 90;
    }

    // for every target, there's one setting:
    boost::array<std::string, 2> targetnames; 
    boost::array<std::string, 2> framenames; 
    boost::array<Real[4],2> maxranges; 
    boost::array<Real[4],2> minranges; 
    boost::array<Real[4],2> stepsizes; 
    boost::array<int,2> ignorebasecollisions; 

    // shared settings
    std::string unit; 
    int topstorecandidates; 
};

class RobotProgramData
{
public:
    RobotProgramData() {
    }
    RobotProgramData(const std::string& programdata, const std::string& type) : programdata(programdata), type(type) {
    }
    std::string programdata; 
    std::string type; 
};

class RobotControllerPrograms
{
public:
    std::map<std::string, RobotProgramData> programs; 
};

class MUJINCLIENT_API ControllerClient
{
public:
    virtual ~ControllerClient() {
    }

//    \brief Returns a list of filenames in the user system of a particular type
//
//        \param scenetype the type of scene possible values are:
//        - mujincollada
//        - wincaps
//        - rttoolbox
//        - cecrobodiaxml
//        - stl
//        - x
//        - vrml
//        - stl
//
//    virtual void GetSceneFilenames(const std::string& scenetype, std::vector<std::string>& scenefilenames) = 0;

    virtual void SetCharacterEncoding(const std::string& newencoding) = 0;

    virtual void SetLanguage(const std::string& language) = 0;

    virtual const std::string& GetUserName() const = 0;

    virtual void SetProxy(const std::string& serverport, const std::string& userpw) = 0;

    virtual void RestartServer() = 0;

    virtual void Upgrade(const std::vector<unsigned char>& vdata) = 0;

    virtual std::string GetVersion() = 0;

    virtual void CancelAllJobs() = 0;

    virtual void GetRunTimeStatuses(std::vector<JobStatus>& statuses, int options=0) = 0;

    virtual void GetScenePrimaryKeys(std::vector<std::string>& scenekeys) = 0;

    virtual SceneResourcePtr RegisterScene_UTF8(const std::string& uri, const std::string& scenetype) = 0;

    virtual SceneResourcePtr RegisterScene_UTF8(const std::string& uri)
    {
        return RegisterScene_UTF8(uri,GetDefaultSceneType());
    }

    virtual SceneResourcePtr RegisterScene_UTF16(const std::wstring& uri, const std::string& scenetype) = 0;

    virtual SceneResourcePtr RegisterScene_UTF16(const std::wstring& uri)
    {
        return RegisterScene_UTF16(uri,GetDefaultSceneType());
    }

    virtual SceneResourcePtr ImportSceneToCOLLADA_UTF8(const std::string& sourceuri, const std::string& sourcescenetype, const std::string& newuri, bool overwrite=false) = 0;

    virtual SceneResourcePtr ImportSceneToCOLLADA_UTF16(const std::wstring& sourceuri, const std::string& sourcescenetype, const std::wstring& newuri, bool overwrite=false) = 0;

    virtual void SyncUpload_UTF8(const std::string& sourcefilename, const std::string& destinationdir, const std::string& scenetype) = 0;

    virtual void SyncUpload_UTF8(const std::string& sourcefilename, const std::string& destinationdir)
    {
        SyncUpload_UTF8(sourcefilename, destinationdir, GetDefaultSceneType());
    }

    virtual void SyncUpload_UTF16(const std::wstring& sourcefilename, const std::wstring& destinationdir, const std::string& scenetype) = 0;

    virtual void SyncUpload_UTF16(const std::wstring& sourcefilename, const std::wstring& destinationdir)
    {
        SyncUpload_UTF16(sourcefilename, destinationdir, GetDefaultSceneType());
    }

    virtual void UploadFileToController_UTF8(const std::string& filename, const std::string& desturi) = 0;

    virtual void UploadFileToController_UTF16(const std::wstring& filename, const std::wstring& desturi) = 0;

    virtual void UploadDataToController_UTF8(const std::vector<unsigned char>& vdata, const std::string& desturi) = 0;

    virtual void UploadDirectoryToController_UTF8(const std::string& copydir, const std::string& desturi) = 0;

    virtual void UploadDirectoryToController_UTF16(const std::wstring& copydir, const std::wstring& desturi) = 0;

    virtual void DownloadFileFromController_UTF8(const std::string& desturi, std::vector<unsigned char>& vdata) = 0;
    virtual void DownloadFileFromController_UTF16(const std::wstring& desturi, std::vector<unsigned char>& vdata) = 0;

    virtual void DownloadFileFromControllerIfModifiedSince_UTF8(const std::string& desturi, long localtimeval, long &remotetimeval, std::vector<unsigned char>& vdata) = 0;

    virtual void DownloadFileFromControllerIfModifiedSince_UTF16(const std::wstring& desturi, long localtimeval, long &remotetimeval, std::vector<unsigned char>& vdata) = 0;

    virtual void DeleteFileOnController_UTF8(const std::string& uri) = 0;

    virtual void DeleteFileOnController_UTF16(const std::wstring& uri) = 0;

    virtual void DeleteDirectoryOnController_UTF8(const std::string& uri) = 0;

    virtual void DeleteDirectoryOnController_UTF16(const std::wstring& uri) = 0;

    virtual void SetDefaultSceneType(const std::string& scenetype) = 0;

    virtual const std::string& GetDefaultSceneType() = 0;

    virtual void SetDefaultTaskType(const std::string& tasktype) = 0;

    virtual const std::string& GetDefaultTaskType() = 0;

    virtual std::string GetScenePrimaryKeyFromURI_UTF8(const std::string& uri) = 0;

    virtual std::string GetScenePrimaryKeyFromURI_UTF16(const std::wstring& uri) = 0;

    virtual std::string GetPrimaryKeyFromName_UTF8(const std::string& name) = 0;

    virtual std::string GetPrimaryKeyFromName_UTF16(const std::wstring& name) = 0;

    virtual std::string GetNameFromPrimaryKey_UTF8(const std::string& pk) = 0;

    virtual std::wstring GetNameFromPrimaryKey_UTF16(const std::string& pk) = 0;
};

class MUJINCLIENT_API WebResource
{
public:
    WebResource(ControllerClientPtr controller, const std::string& resourcename, const std::string& pk);
    virtual ~WebResource() {
    }

    inline ControllerClientPtr GetController() const {
        return __controller;
    }
    inline const std::string& GetResourceName() const {
        return __resourcename;
    }
    inline const std::string& GetPrimaryKey() const {
        return __pk;
    }

    virtual std::string Get(const std::string& field);

    virtual void Set(const std::string& field, const std::string& newvalue);

    virtual void Delete();

    virtual void Copy(const std::string& newname, int options);

private:
    ControllerClientPtr __controller;
    std::string __resourcename, __pk;
};

class MUJINCLIENT_API ObjectResource : public WebResource
{
public:
    class MUJINCLIENT_API LinkResource : public WebResource {
public:
        LinkResource(ControllerClientPtr controller, const std::string& objectpk, const std::string& pk);
        virtual ~LinkResource() {
        }

        std::vector<std::string> attachmentpks;
        std::string name;
        std::string pk;
        //TODO transforms
    };
    typedef boost::shared_ptr<LinkResource> LinkResourcePtr;

    ObjectResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~ObjectResource() {
    }

    virtual void GetLinks(std::vector<LinkResourcePtr>& links);

    std::string name;
    int nundof;
    std::string datemodified;
    std::string geometry;
    bool isrobot;
    std::string pk;
    std::string resource_uri;
    std::string scenepk;
    std::string unit;
    std::string uri;

protected:
    ObjectResource(ControllerClientPtr controller, const std::string& resource, const std::string& pk);

};

class MUJINCLIENT_API RobotResource : public ObjectResource
{
public:
    class MUJINCLIENT_API ToolResource : public WebResource {
public:
        ToolResource(ControllerClientPtr controller, const std::string& robotobjectpk, const std::string& pk);
        virtual ~ToolResource() {
        }

        std::string name;
        std::string frame_origin;
        std::string frame_tip;
        std::string pk;
        Real direction[3];
        Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
        Real translate[3];
    };
    typedef boost::shared_ptr<ToolResource> ToolResourcePtr;

    class MUJINCLIENT_API AttachedSensorResource : public WebResource {
public:
        AttachedSensorResource(ControllerClientPtr controller, const std::string& robotobjectpk, const std::string& pk);
        virtual ~AttachedSensorResource() {
        }

        std::string name;
        std::string frame_origin;
        std::string pk;
        //Real direction[3];
        Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
        Real translate[3];
        std::string sensortype;

        class SensorData {
public:
            Real distortion_coeffs[5];
            std::string distortion_model;
            Real focal_length;
            int image_dimensions[3];
            Real intrinsic[6];
            Real measurement_time;
            std::vector<Real> extra_parameters;
        };
        SensorData sensordata;
    };

    typedef boost::shared_ptr<AttachedSensorResource> AttachedSensorResourcePtr;

    RobotResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~RobotResource() {
    }

    virtual void GetTools(std::vector<ToolResourcePtr>& tools);
    virtual void GetAttachedSensors(std::vector<AttachedSensorResourcePtr>& attachedsensors);

    // attachments
    // ikparams
    // images
    int numdof;
    std::string simulation_file;
};

class MUJINCLIENT_API SceneResource : public WebResource
{
public:
    class InstObject;
    typedef boost::shared_ptr<InstObject> InstObjectPtr;
    class MUJINCLIENT_API InstObject : public WebResource
    {
public:
        InstObject(ControllerClientPtr controller, const std::string& scenepk, const std::string& pk);
        virtual ~InstObject() {
        }

        class MUJINCLIENT_API Link {
public:
            std::string name;
            Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
            Real translate[3];
        };

        class MUJINCLIENT_API Tool {
public:
            std::string name;
            Real direction[3];
            Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
            Real translate[3];
        };

        class MUJINCLIENT_API Grab {
public:
            std::string instobjectpk; 
            std::string grabbed_linkpk;
            std::string grabbing_linkpk;

            std::string Serialize() {
                return boost::str(boost::format("{\"instobjectpk\": \"%s\", \"grabbed_linkpk\": \"%s\",  \"grabbing_linkpk\": \"%s\"}")%instobjectpk%grabbed_linkpk%grabbing_linkpk);
            }

            bool operator==(const Grab grab) {
                if (this->instobjectpk == grab.instobjectpk
                    && this->grabbed_linkpk == grab.grabbed_linkpk
                    && this->grabbing_linkpk == grab.grabbing_linkpk) {
                    return true;
                }
                return false;
            }
        };

        class MUJINCLIENT_API AttachedSensor {
public:
            std::string name;
            Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
            Real translate[3];
        };

        void SetTransform(const Transform& t);
        void SetDOFValues();
        virtual void GrabObject(InstObjectPtr grabbedobject, std::string& grabbedobjectlinkpk, std::string& grabbinglinkpk);
        virtual void ReleaseObject(InstObjectPtr grabbedobject, std::string& grabbedobjectlinkpk, std::string& grabbinglinkpk);


        std::vector<Real> dofvalues;
        std::string name;
        std::string pk;
        std::string object_pk;
        std::string reference_uri;
        Real quaternion[4]; // quaternion [w, x, y, z] = [cos(angle/2), sin(angle/2)*rotation_axis]
        Real translate[3];
        std::vector<Grab> grabs;
        std::vector<Link> links;
        std::vector<Tool> tools;
        std::vector<AttachedSensor> attachedsensors;
    };

    SceneResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~SceneResource() {
    }

    virtual void SetInstObjectsState(const std::vector<SceneResource::InstObjectPtr>& instobjects, const std::vector<InstanceObjectState>& states);

    virtual TaskResourcePtr GetOrCreateTaskFromName_UTF8(const std::string& taskname, const std::string& tasktype, int options=0);

    virtual TaskResourcePtr GetOrCreateTaskFromName_UTF8(const std::string& taskname, int options=0)
    {
        return GetOrCreateTaskFromName_UTF8(taskname, GetController()->GetDefaultTaskType(), options);
    }

    virtual TaskResourcePtr GetTaskFromName_UTF8(const std::string& taskname, int options=0);

    virtual TaskResourcePtr GetOrCreateTaskFromName_UTF16(const std::wstring& taskname, const std::string& tasktype, int options=0);

    virtual TaskResourcePtr GetOrCreateTaskFromName_UTF16(const std::wstring& taskname, int options=0)
    {
        return GetOrCreateTaskFromName_UTF16(taskname, GetController()->GetDefaultTaskType(), options);
    }

    virtual TaskResourcePtr GetTaskFromName_UTF16(const std::wstring& taskname, int options=0);


    virtual BinPickingTaskResourcePtr GetOrCreateBinPickingTaskFromName_UTF8(const std::string& taskname, const std::string& tasktype="binpicking", int options=0);
    virtual BinPickingTaskResourcePtr GetOrCreateBinPickingTaskFromName_UTF16(const std::wstring& taskname, const std::string& tasktype="binpicking", int options=0);


    virtual void GetTaskPrimaryKeys(std::vector<std::string>& taskkeys);

    virtual void GetSensorMapping(std::map<std::string, std::string>& sensormapping);
    virtual void GetInstObjects(std::vector<InstObjectPtr>& instobjects);
    virtual bool FindInstObject(const std::string& name, InstObjectPtr& instobject);

    virtual SceneResource::InstObjectPtr CreateInstObject(const std::string& name, const std::string& reference_uri, Real quaternion[4], Real translate[3]);

    virtual SceneResourcePtr Copy(const std::string& name);
};

class MUJINCLIENT_API TaskResource : public WebResource
{
public:
    TaskResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~TaskResource() {
    }

    virtual bool Execute();

    virtual void Cancel();

    virtual void GetRunTimeStatus(JobStatus& status, int options = 1);

    virtual OptimizationResourcePtr GetOrCreateOptimizationFromName_UTF8(const std::string& optimizationname, const std::string& optimizationtype=std::string("robotplacement"));

    virtual OptimizationResourcePtr GetOrCreateOptimizationFromName_UTF16(const std::wstring& optimizationname, const std::string& optimizationtype=std::string("robotplacement"));

    virtual void GetOptimizationPrimaryKeys(std::vector<std::string>& optimizationkeys);

    virtual void GetTaskParameters(ITLPlanningTaskParameters& taskparameters);

    virtual void SetTaskParameters(const ITLPlanningTaskParameters& taskparameters);

    virtual PlanningResultResourcePtr GetResult();

protected:
    std::string _jobpk; 
};

class MUJINCLIENT_API OptimizationResource : public WebResource
{
public:
    OptimizationResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~OptimizationResource() {
    }

    virtual void Execute(bool bClearOldResults=true);

    virtual void Cancel();

    void SetOptimizationParameters(const RobotPlacementOptimizationParameters& optparams);

    void SetOptimizationParameters(const PlacementsOptimizationParameters& optparams);

    virtual void GetRunTimeStatus(JobStatus& status, int options = 1);

    virtual void GetResults(std::vector<PlanningResultResourcePtr>& results, int startoffset=0, int num=0);

protected:
    std::string _jobpk; 
};

class MUJINCLIENT_API PlanningResultResource : public WebResource
{
public:
    PlanningResultResource(ControllerClientPtr controller, const std::string& resulttype, const std::string& pk);
    PlanningResultResource(ControllerClientPtr controller, const std::string& pk);
    virtual ~PlanningResultResource() {
    }

    virtual void GetEnvironmentState(EnvironmentState& envstate);

    virtual void GetAllRawProgramData(std::string& outputdata, const std::string& programtype="auto");

    virtual void GetRobotRawProgramData(std::string& outputdata, const std::string& robotpk, const std::string& programtype="auto");

    virtual void GetPrograms(RobotControllerPrograms& programs, const std::string& programtype="auto");
};

MUJINCLIENT_API ControllerClientPtr CreateControllerClient(const std::string& usernamepassword, const std::string& url=std::string(), const std::string& proxyserverport=std::string(), const std::string& proxyuserpw=std::string(), int options=0);

MUJINCLIENT_API void DestroyControllerClient();

MUJINCLIENT_API void ControllerClientDestroy() MUJINCLIENT_DEPRECATED;

MUJINCLIENT_API void ComputeMatrixFromTransform(Real matrix[12], const Transform &transform);

MUJINCLIENT_API void ComputeZXYFromMatrix(Real ZXY[3], const Real matrix[12]);

MUJINCLIENT_API void ComputeZXYFromTransform(Real ZXY[3], const Transform &transform);

MUJINCLIENT_API void SerializeEnvironmentStateToJSON(const EnvironmentState& envstate, std::ostream& os);

}

#if !defined(MUJINCLIENT_DISABLE_ASSERT_HANDLER) && defined(BOOST_ENABLE_ASSERT_HANDLER)

namespace boost
{
inline void assertion_failed(char const * expr, char const * function, char const * file, long line)
{
    throw mujinclient::MujinException(boost::str(boost::format("[%s:%d] -> %s, expr: %s")%file%line%function%expr),mujinclient::MEC_Assert);
}

#if BOOST_VERSION>104600
inline void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line)
{
    throw mujinclient::MujinException(boost::str(boost::format("[%s:%d] -> %s, expr: %s, msg: %s")%file%line%function%expr%msg),mujinclient::MEC_Assert);
}
#endif

}
#endif

BOOST_STATIC_ASSERT(MUJINCLIENT_VERSION_MAJOR>=0&&MUJINCLIENT_VERSION_MAJOR<=255);
BOOST_STATIC_ASSERT(MUJINCLIENT_VERSION_MINOR>=0&&MUJINCLIENT_VERSION_MINOR<=255);
BOOST_STATIC_ASSERT(MUJINCLIENT_VERSION_PATCH>=0&&MUJINCLIENT_VERSION_PATCH<=255);

#endif