environmentEntitiesCommands.h

Go to the documentation of this file.

//  ConscienceRobotManager
//
//  Created by Louis Grignon on 21/12/2022.
//  Copyright © 2022 IliesZaoui. All rights reserved.
//
#ifndef environmentEntitiesCommands_h
#define environmentEntitiesCommands_h
 
#include "./ArtificialIntelligence/Algorithms/pathFinding.h"
#include "./ArtificialIntelligence/MultiEntity/CscMoveForwardInGroup.h"
#include "CommandCommons.h"
#include "CommandEntityToPosition.h"
 
#include <Communication/CscMessagingRequestContext.h>
 
using namespace conscience_core::ai::algorithms::path_finding;
namespace conscience_core::lidar::directions {
struct CSC_DLL_IMPORTEXPORT CscAvailableDirection;
}
using namespace conscience_core::lidar::directions;
 
namespace conscience_core::bridging::commands::environment_entities {
 
class CSC_DLL_IMPORTEXPORT CommandEntityCaptureImageToEnv : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_CAPTURE_IMAGE_TO_ENV";
 
    CommandEntityCaptureImageToEnv(
        ptr<CscEntityReflexion> entityReflexion,
        CscPoint3d *position = nullptr,
        CscPoint3d *rotation = nullptr);
 
    ~CommandEntityCaptureImageToEnv() override;
 
protected:
    ptr<CscEntityReflexion> getEntityReflexion() const override;
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    CscPoint3d *const position = nullptr;
    CscPoint3d *const rotation = nullptr;
};
COMMAND_TYPE_BUILDER(CommandEntityCaptureImageToEnv, CscPoint3d, double, double, double)
COMMAND_REGISTER(CommandEntityCaptureImageToEnv, ptr<CscEntityReflexion>, CscPoint3d *, CscPoint3d *)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntityProcess : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_PROCESS";
 
    CommandEntityProcess(
        ptr<CscEntityReflexion> entityReflexion,
        const string &command,
        bool useUdp = false);
 
    ~CommandEntityProcess() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    const string command;
    bool useUdp;
};
 
COMMAND_REGISTER(CommandEntityProcess, ptr<CscEntityReflexion>, const string &, bool)
 
struct CSC_DLL_IMPORTEXPORT WorldEntityCommandDataType {
    WorldEntityCommandDataType(
        const string &id,
        const string &name,
        const string &modelId,
        CscPoint3d *position,
        const CscRotation3dEuler *rotationEuler,
        const CscQuaternion *rotationQuaternion,
        const string &entityStatusFlags,
        const optional<unsigned long long> &currentSequenceIndex);
 
    virtual ~WorldEntityCommandDataType();
 
    const string id;
    const string name;
    const string modelId;
    CscPoint3d *const position;
    const CscRotation3dEuler *rotationEuler = nullptr;
    const string entityStatusFlags;
    const optional<unsigned long long> currentSequenceIndex;
    const CscQuaternion *rotationQuaternion = nullptr;
};
 
struct CSC_DLL_IMPORTEXPORT EntitiesGetFiltersCommandDataType {
    EntitiesGetFiltersCommandDataType(
        CscArea3d *zone = nullptr,
        vector<string> *ids = nullptr,
        vector<string> *modelIds = nullptr);
 
    virtual ~EntitiesGetFiltersCommandDataType();
 
    CscArea3d *const zone;
    vector<string> *const ids;
    vector<string> *const modelIds;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntitiesGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITIES_GET";
 
    CommandEntitiesGet(const EntitiesGetFiltersCommandDataType *filters = nullptr);
 
    ~CommandEntitiesGet() override;
 
protected:
    const CscCommandExecutionResultList<WorldEntityCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const EntitiesGetFiltersCommandDataType *const filters;
};
 
COMMAND_RESULT_JSON_SERIALIZER(CscQuaternion, w, x, y, z)
COMMAND_RESULT_JSON_SERIALIZER(CscPoint3d, x, y, z)
COMMAND_RESULT_JSON_SERIALIZER(WorldEntityCommandDataType,
                               id,
                               name,
                               modelId,
                               position,
                               rotationEuler,
                               entityStatusFlags,
                               currentSequenceIndex,
                               rotationQuaternion)
COMMAND_REGISTER(CommandEntitiesGet, const EntitiesGetFiltersCommandDataType *)
 
ENUM(EntityStreamFormat,
     MJPG,
     RTSP);
 
struct CSC_DLL_IMPORTEXPORT EntityStreamCommandDataType {
    EntityStreamCommandDataType(
        const string &id,
        const string &accessData,
        EntityStreamFormat type,
        const optional<string> &directStreamUrl = {},
        bool is360 = false);
 
    virtual ~EntityStreamCommandDataType();
 
    const string id;
    const string accessData;
    const optional<string> directStreamUrl;
    const EntityStreamFormat type;
    const bool is360;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityStreamsGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_STREAMS_GET";
 
    CommandEntityStreamsGet(ptr<CscEntityReflexion> entityReflexion);
 
    ~CommandEntityStreamsGet() override;
 
protected:
    const CscCommandExecutionResultList<EntityStreamCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
};
 
COMMAND_RESULT_JSON_SERIALIZER(EntityStreamCommandDataType,
                               id,
                               accessData,
                               directStreamUrl,
                               type,
                               is360)
COMMAND_REGISTER(CommandEntityStreamsGet, ptr<CscEntityReflexion>)
 
struct CSC_DLL_IMPORTEXPORT EntityStreamStartParamsCommandDataType {
    EntityStreamStartParamsCommandDataType();
 
    EntityStreamStartParamsCommandDataType(
        const string &entitySerialNumber,
        const string &streamId,
        bool withAIOverlay = false,
        bool noErrorIfStreamUnavailable = false);
 
    virtual ~EntityStreamStartParamsCommandDataType();
 
    const string entitySerialNumber;
    const string streamId;
    const bool withAIOverlay;
    const bool noErrorIfStreamUnavailable;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityStreamStart : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_STREAM_START";
 
    CommandEntityStreamStart(const EntityStreamStartParamsCommandDataType *parameters);
 
    ~CommandEntityStreamStart() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const EntityStreamStartParamsCommandDataType *const parameters;
    ptr<CscEntityReflexion> entityReflexion = nullptr;
};
 
COMMAND_TYPE_BUILDER(CommandEntityStreamStart, EntityStreamStartParamsCommandDataType, const string &, const string &, bool, bool)
COMMAND_REGISTER(CommandEntityStreamStart, const EntityStreamStartParamsCommandDataType *)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntitiesRemove : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITIES_REMOVE";
 
    CommandEntitiesRemove(const EntitiesGetFiltersCommandDataType *filters = nullptr);
 
    ~CommandEntitiesRemove() override;
 
protected:
    const CscCommandExecutionResultList<string> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const EntitiesGetFiltersCommandDataType *const filters;
};
 
COMMAND_TYPE_BUILDER(CommandEntitiesRemove, CscArea3d, double, double, double, double, double, double)
COMMAND_TYPE_BUILDER(CommandEntitiesRemove, EntitiesGetFiltersCommandDataType, CscArea3d *, vector<string> *, vector<string> *)
COMMAND_REGISTER(CommandEntitiesRemove, const EntitiesGetFiltersCommandDataType *)
 
struct CSC_DLL_IMPORTEXPORT EntityVideoSourceLocalFileCommandDataType {
    EntityVideoSourceLocalFileCommandDataType();
 
    EntityVideoSourceLocalFileCommandDataType(const string &videoFilePath);
 
    virtual ~EntityVideoSourceLocalFileCommandDataType();
 
    string videoFilePath;
};
 
struct CSC_DLL_IMPORTEXPORT EntityVideoSourceLocalDeviceCommandDataType {
    EntityVideoSourceLocalDeviceCommandDataType();
 
    EntityVideoSourceLocalDeviceCommandDataType(int deviceId, optional<int> frameWidth = {}, optional<int> frameHeight = {}, optional<int> fps = {});
 
    virtual ~EntityVideoSourceLocalDeviceCommandDataType();
 
    int deviceId;
    optional<int> frameWidth;
    optional<int> frameHeight;
    optional<int> fps;
};
 
struct CSC_DLL_IMPORTEXPORT EntityVideoSourceNetworkStreamCommandDataType {
    EntityVideoSourceNetworkStreamCommandDataType();
 
    EntityVideoSourceNetworkStreamCommandDataType(const string &streamUrl, optional<bool> is360 = {});
 
    virtual ~EntityVideoSourceNetworkStreamCommandDataType();
 
    string streamUrl;
    bool is360;
};
 
struct CSC_DLL_IMPORTEXPORT EntityVideoSourcesCommandDataType {
 
    EntityVideoSourcesCommandDataType(
        vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *localFileSources = nullptr,
        vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *localDeviceSources = nullptr,
        vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *networkStreamSources = nullptr);
 
    virtual ~EntityVideoSourcesCommandDataType();
 
    vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *localFileSources;
    vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *localDeviceSources;
    vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *networkStreamSources;
};
 
struct CSC_DLL_IMPORTEXPORT RealEntityNetworkParamsCommandDataType {
    RealEntityNetworkParamsCommandDataType();
 
    RealEntityNetworkParamsCommandDataType(
        const string &entityIp,
        const string &entityPassword,
        unsigned long long portUdp = ENTITY_PORT_UDP_DEFAULT,
        unsigned long long portTcp = ENTITY_PORT_TCP_DEFAULT,
        bool openRtspStream = false,
        vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *additionalNetworkStreams = nullptr,
        vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *additionalLocalFileSources = nullptr,
        vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *additionalLocalDeviceSources = nullptr);
 
    virtual ~RealEntityNetworkParamsCommandDataType();
 
    RealEntityNetworkParamsCommandDataType *clone() const;
 
    string entityIp;
    string entityPassword;
    unsigned long long portUdp;
    unsigned long long portTcp;
    bool openRtspStream;
    vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *additionalNetworkStreams;
    vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *additionalLocalFileSources;
    vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *additionalLocalDeviceSources;
};
 
struct CSC_DLL_IMPORTEXPORT CommandEntityConnectResult {
    string serialNumber;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityConnect : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_CONNECT";
 
    CommandEntityConnect(const RealEntityNetworkParamsCommandDataType *parameters);
 
    ~CommandEntityConnect() override;
 
protected:
    const CscCommandExecutionResultObject<CommandEntityConnectResult> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const RealEntityNetworkParamsCommandDataType *const parameters;
};
 
COMMAND_TYPE_BUILDER(CommandEntityConnect, EntityVideoSourceLocalFileCommandDataType, const string &)
COMMAND_TYPE_BUILDER(CommandEntityConnect, EntityVideoSourceNetworkStreamCommandDataType, const string &, optional<bool>)
COMMAND_TYPE_BUILDER(CommandEntityConnect, EntityVideoSourceLocalDeviceCommandDataType, int, optional<int>, optional<int>, optional<int>)
COMMAND_TYPE_BUILDER(CommandEntityConnect, RealEntityNetworkParamsCommandDataType, const string &, const string &,
                     unsigned long long,
                     unsigned long long,
                     bool,
                     vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *,
                     vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *,
                     vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *)
COMMAND_RESULT_JSON_SERIALIZER(CommandEntityConnectResult, serialNumber)
COMMAND_REGISTER(CommandEntityConnect, const RealEntityNetworkParamsCommandDataType *)
 
struct CSC_DLL_IMPORTEXPORT EntityPendingInsertionCommandDataType {
    EntityPendingInsertionCommandDataType();
 
    EntityPendingInsertionCommandDataType(
        const string &serialNumber,
        const string &modelId,
        EntityVideoSourcesCommandDataType *videoSources = nullptr,
        CscPoint3d *position = nullptr,
        CscPoint3d *rotation = nullptr,
        bool isSimulatedEntity = true,
        bool useGnssPositioning = false,
        const RealEntityNetworkParamsCommandDataType *realEntityNetworkParams = nullptr,
        optional<PositionFormat> simulatedInputsType = {});
 
    virtual ~EntityPendingInsertionCommandDataType();
 
    string serialNumber;
    string modelId;
    EntityVideoSourcesCommandDataType *videoSources;
    CscPoint3d *position;
    CscPoint3d *rotation;
    bool isSimulatedEntity;
    bool useGnssPositioning;
    const RealEntityNetworkParamsCommandDataType *realEntityNetworkParams;
    optional<PositionFormat> simulatedInputsType;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntitiesInsert : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITIES_INSERT";
 
    CommandEntitiesInsert(const vector<ptr<EntityPendingInsertionCommandDataType>> *data);
 
    ~CommandEntitiesInsert() override;
 
protected:
    const CscCommandExecutionResultList<string> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const vector<ptr<EntityPendingInsertionCommandDataType>> *const data;
};
COMMAND_TYPE_BUILDER(CommandEntitiesInsert, EntityVideoSourceLocalFileCommandDataType, const string &)
COMMAND_TYPE_BUILDER(CommandEntitiesInsert, EntityVideoSourceNetworkStreamCommandDataType, const string &, optional<bool>)
COMMAND_TYPE_BUILDER(CommandEntitiesInsert, EntityVideoSourceLocalDeviceCommandDataType, int, optional<int>, optional<int>, optional<int>)
COMMAND_TYPE_BUILDER(CommandEntitiesInsert, EntityVideoSourcesCommandDataType,
                     vector<ptr<EntityVideoSourceLocalFileCommandDataType>> *,
                     vector<ptr<EntityVideoSourceLocalDeviceCommandDataType>> *,
                     vector<ptr<EntityVideoSourceNetworkStreamCommandDataType>> *)
COMMAND_TYPE_BUILDER(CommandEntitiesInsert, EntityPendingInsertionCommandDataType, const string &,
                     const string &,
                     EntityVideoSourcesCommandDataType *,
                     CscPoint3d *,
                     CscPoint3d *,
                     bool,
                     bool,
                     const RealEntityNetworkParamsCommandDataType *,
                     optional<PositionFormat>)
COMMAND_REGISTER(CommandEntitiesInsert, const vector<ptr<EntityPendingInsertionCommandDataType>> *)
 
class CSC_DLL_IMPORTEXPORT CommandEntityInsert : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_INSERT";
 
    CommandEntityInsert(const CscEntityModel *entityModel, ptr<CscPoint3d> position, ptr<CscPoint3d> rotation, optional<string> serialNumber);
    ~CommandEntityInsert() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const CscEntityModel *const entityModel;
    ptr<CscPoint3d> position;
    ptr<CscPoint3d> rotation;
    optional<string> serialNumber;
};
COMMAND_REGISTER(CommandEntityInsert, CscEntityModel *, ptr<CscPoint3d>, ptr<CscPoint3d>, optional<string>)
 
struct CSC_DLL_IMPORTEXPORT EntityModelCommandDataType {
    EntityModelCommandDataType();
 
    EntityModelCommandDataType(
        const string &id,
        const string &name,
        const string &entityType,
        const string &owner,
        unsigned long long lastModificationTimeMillis);
 
    virtual ~EntityModelCommandDataType();
 
    string id;
    string name;
    string entityType;
    string owner;
    unsigned long long lastModificationTimeMillis;
};
 
struct CSC_DLL_IMPORTEXPORT EntityModelsGetFiltersCommandDataType {
    EntityModelsGetFiltersCommandDataType();
 
    EntityModelsGetFiltersCommandDataType(const optional<string> &entityType);
 
    virtual ~EntityModelsGetFiltersCommandDataType();
 
    optional<string> entityType;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityModelsGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_MODELS_GET";
 
    CommandEntityModelsGet(const EntityModelsGetFiltersCommandDataType *filters = nullptr);
 
    ~CommandEntityModelsGet() override;
 
protected:
    const CscCommandExecutionResultList<EntityModelCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const EntityModelsGetFiltersCommandDataType *const filters;
};
 
COMMAND_TYPE_BUILDER(CommandEntityModelsGet, EntityModelCommandDataType, const string &, const string &, const string &, const string &, unsigned long long)
COMMAND_RESULT_JSON_SERIALIZER(EntityModelCommandDataType, id, name, entityType, owner, lastModificationTimeMillis)
COMMAND_REGISTER(CommandEntityModelsGet, const EntityModelsGetFiltersCommandDataType *)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntityModelLogoGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_MODEL_LOGO_GET";
 
    CommandEntityModelLogoGet(const CscEntityModel *entityModel, const optional<unsigned long long> &ifModifiedSinceTimestampMillis = nullopt);
 
    ~CommandEntityModelLogoGet() override;
 
protected:
    const CscCommandExecutionResultBinary *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const CscEntityModel *entityModel;
    optional<unsigned long long> ifModifiedSinceTimestampMillis;
};
 
COMMAND_REGISTER(CommandEntityModelLogoGet, const CscEntityModel *, const optional<unsigned long long> &)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntityModelSourceFileGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_MODEL_SOURCE_FILE_GET";
 
    CommandEntityModelSourceFileGet(const CscEntityModel *entityModel, CscWorldElementModelFormat format);
 
    ~CommandEntityModelSourceFileGet() override;
 
protected:
    const CscCommandExecutionResultBinary *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    const CscEntityModel *entityModel;
    CscWorldElementModelFormat format;
};
 
COMMAND_REGISTER(CommandEntityModelSourceFileGet, const CscEntityModel *, CscWorldElementModelFormat)
 
 
struct CSC_DLL_IMPORTEXPORT CommandEntityGetCurrentPathResult {
    optional<vector<const CscPoint3d *>> path = {};
    optional<int> index = {};
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityGetCurrentPath : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_GET_CURRENT_PATH";
 
    CommandEntityGetCurrentPath(const string &serialNumber);
 
    ~CommandEntityGetCurrentPath() override;
 
protected:
    const CscCommandExecutionResultObject<CommandEntityGetCurrentPathResult> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string serialNumber;
};
 
COMMAND_RESULT_JSON_SERIALIZER(CommandEntityGetCurrentPathResult, path, index)
COMMAND_REGISTER(CommandEntityGetCurrentPath, const string &)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntityClearCurrentPath : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_CLEAR_CURRENT_PATH";
 
    CommandEntityClearCurrentPath(const string &serialNumber);
 
    ~CommandEntityClearCurrentPath() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string serialNumber;
};
 
COMMAND_REGISTER(CommandEntityClearCurrentPath, const string &)
 
struct CSC_DLL_IMPORTEXPORT EntityToPositionGetClosestValidPositionResult {
    EntityToPositionGetClosestValidPositionResult();
 
    EntityToPositionGetClosestValidPositionResult(CscPoint3d *position);
 
    virtual ~EntityToPositionGetClosestValidPositionResult();
 
    CscPoint3d *position;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityToPositionGetClosestValidPosition : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_TO_POSITION_GET_CLOSEST_VALID_POSITION";
 
    CommandEntityToPositionGetClosestValidPosition(
        const CscPoint3d *targetPosition,
        ptr<CscEntityReflexion> entityReflexion,
        CscArea3d *zone = nullptr,
        optional<double> distanceWithObjectAutorized = {},
        optional<int> matrixSize = {},
        const CscPoint3d *startPosition = nullptr,
        optional<bool> useGnssCoordinates = {},
        const vector<string> *placeModelIdsToIgnore = nullptr,
        optional<CommandEntityToPositionAlgorithm> algorithm = {});
 
    ~CommandEntityToPositionGetClosestValidPosition() override;
 
protected:
    const CscCommandExecutionResultObject<EntityToPositionGetClosestValidPositionResult> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    optional<CommandEntityToPositionAlgorithm> algorithm;
    const CscPoint3d *targetPosition;
    ptr<CscEntityReflexion> entityReflexion;
    CscArea3d *zone;
    optional<double> distanceWithObjectAutorized;
    optional<int> matrixSize;
    const CscPoint3d *startPosition;
    optional<bool> useGnssCoordinates;
    const vector<string> *const placeModelIdsToIgnore;
};
 
COMMAND_RESULT_JSON_SERIALIZER(EntityToPositionGetClosestValidPositionResult, position)
COMMAND_REGISTER(CommandEntityToPositionGetClosestValidPosition, const CscPoint3d *, ptr<CscEntityReflexion>, CscArea3d *, optional<double>, optional<int>, const CscPoint3d *, optional<bool>, const vector<string> *, optional<CommandEntityToPositionAlgorithm>)
 
struct CSC_DLL_IMPORTEXPORT EntityMotionParametersCommandDataType {
    EntityMotionParametersCommandDataType();
 
    EntityMotionParametersCommandDataType(
        const optional<double> &translationX,
        const optional<double> &translationY,
        const optional<double> &translationZ,
        const optional<double> &rotationX,
        const optional<double> &rotationY,
        const optional<double> &rotationZ);
 
    virtual ~EntityMotionParametersCommandDataType();
 
    optional<double> translationX;
    optional<double> translationY;
    optional<double> translationZ;
    optional<double> rotationX;
    optional<double> rotationY;
    optional<double> rotationZ;
};
 
class CSC_DLL_IMPORTEXPORT CommandEntityPlayMotion : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_PLAY_MOTION";
 
    CommandEntityPlayMotion(const string &entitySerial, const EntityMotionParametersCommandDataType *motionParameters);
 
    ~CommandEntityPlayMotion() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string entitySerial;
    const EntityMotionParametersCommandDataType *const motionParameters;
};
 
COMMAND_TYPE_BUILDER(CommandEntityPlayMotion, EntityMotionParametersCommandDataType, const optional<double>, const optional<double>, const optional<double>, const optional<double>, const optional<double>, const optional<double>)
COMMAND_REGISTER(CommandEntityPlayMotion, const string &, const EntityMotionParametersCommandDataType *)
 
 
class CSC_DLL_IMPORTEXPORT CommandEntitySequenceAction : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_SEQUENCE_ACTION";
 
    CommandEntitySequenceAction(const string &entitySerial, CscSequenceAction action);
 
    ~CommandEntitySequenceAction() override;
 
    const string entitySerial;
    const CscSequenceAction action;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
};
 
COMMAND_REGISTER(CommandEntitySequenceAction, const string &, CscSequenceAction)
 
 
class CSC_DLL_IMPORTEXPORT CommandVisionDetectSingleFrame : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "VISION_DETECT_SINGLE_FRAME";
 
    CommandVisionDetectSingleFrame(const string &entitySerial, ConscienceDetectorType detector);
 
    ~CommandVisionDetectSingleFrame() override;
 
protected:
    const CscCommandExecutionResultList<CscPoint3d> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string entitySerial;
    ConscienceDetectorType detector;
};
COMMAND_REGISTER(CommandVisionDetectSingleFrame, const string &, ConscienceDetectorType)
 
class CSC_DLL_IMPORTEXPORT CommandFollowTrackedObject : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "FOLLOW_TRACKED_OBJECT";
 
    CommandFollowTrackedObject(
        ptr<CscEntityReflexion> entityReflexion,
        int idObjectToFollow, float followDistance, float followAltitude);
 
    ~CommandFollowTrackedObject() override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
    const int idObjectToFollow;
    const float followDistance;
    float followAltitude;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
};
COMMAND_REGISTER(CommandFollowTrackedObject, ptr<CscEntityReflexion>, int, float, float)
 
struct CSC_DLL_IMPORTEXPORT CscEntityClientAndIdentity {
    ptr<CscEntityClient> entityClient;
    optional<ptr<CscEntityIdentity>> entityIdentity;
    optional<string> entityLocalProjection;
};
 
CscEntityClientAndIdentity *getEntityClientAndIdentityFromRealEntityNetworkParams(optional<bool> isSimulated, optional<ptr<RealEntityNetworkParamsCommandDataType>> realEntityNetworkParams);
 
class CSC_DLL_IMPORTEXPORT CommandHumanDecisionAnswer : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_HUMAN_DECISIONS_ANSWER";
 
    CommandHumanDecisionAnswer(
        ptr<CscEntityReflexion> entityReflexion,
        const string &decisionUid,
        bool accept);
 
    ~CommandHumanDecisionAnswer() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    string decisionUid;
    bool accept;
};
 
class CSC_DLL_IMPORTEXPORT CommandHumanDecisionsGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_HUMAN_DECISIONS_GET";
 
    CommandHumanDecisionsGet(ptr<CscEntityReflexion> entityReflexion);
 
    ~CommandHumanDecisionsGet() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
};
 
COMMAND_REGISTER(CommandHumanDecisionAnswer, ptr<CscEntityReflexion>, const string &, bool)
COMMAND_REGISTER(CommandHumanDecisionsGet, ptr<CscEntityReflexion>)
 
class CSC_DLL_IMPORTEXPORT CommandVocalPhoneCallTest : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "VOCAL_PHONE_CALL_TEST";
 
    CommandVocalPhoneCallTest(
        ptr<CscEntityReflexion> entityReflexion,
        const map<string, string> &additionalParams,
        const vector<string> &vocalNotificationPhoneNumbers);
 
    ~CommandVocalPhoneCallTest() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    map<string, string> additionalParams;
    vector<string> vocalNotificationPhoneNumbers;
};
COMMAND_REGISTER(CommandVocalPhoneCallTest, ptr<CscEntityReflexion>, const map<string, string> &, const vector<string> &)
 
class CSC_DLL_IMPORTEXPORT CommandGetLastCartography : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "GET_LAST_CARTOGRAPHY";
 
    CommandGetLastCartography(ptr<CscEntityReflexion> entityReflexion);
 
    ~CommandGetLastCartography() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
};
COMMAND_REGISTER(CommandGetLastCartography, ptr<CscEntityReflexion>)
 
class CSC_DLL_IMPORTEXPORT CommandDrawPathOnSimulator : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "DRAW_PATH_ON_SIMULATOR";
 
    CommandDrawPathOnSimulator(const vector<vector<const CscPoint3d *>> &pointsToDraw);
 
    ~CommandDrawPathOnSimulator() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    vector<vector<const CscPoint3d *>> pointsToDraw;
};
COMMAND_REGISTER(CommandDrawPathOnSimulator, const vector<vector<const CscPoint3d *>> &)
 
class CSC_DLL_IMPORTEXPORT CommandAlertsUnwatch : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ALERTS_UNWATCH";
 
    CommandAlertsUnwatch(
        ptr<CscEntityReflexion> entityReflexion,
        const map<string, string> &additionalParams,
        const vector<CscAlertType> &alertsToBeUnwatched);
 
    ~CommandAlertsUnwatch() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    map<string, string> additionalParams;
    vector<CscAlertType> alertsToBeUnwatched;
};
 
COMMAND_REGISTER(CommandAlertsUnwatch, ptr<CscEntityReflexion>, const map<string, string> &, const vector<CscAlertType> &)
class CSC_DLL_IMPORTEXPORT CommandGetPublicAIDataForSubject : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "GET_PUBLIC_AI_DATA_FOR_SUBJECT";
 
    CommandGetPublicAIDataForSubject(
        ptr<CscEntityReflexion> entityReflexion,
        const string &subject);
 
    ~CommandGetPublicAIDataForSubject() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(
        CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string subject;
    ptr<CscEntityReflexion> entityReflexion;
};
COMMAND_REGISTER(CommandGetPublicAIDataForSubject, ptr<CscEntityReflexion>, const string &)
 
 
class CSC_DLL_IMPORTEXPORT CommandClearPublicAIDataForSubject : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "CLEAR_PUBLIC_AI_DATA_FOR_SUBJECT";
 
    CommandClearPublicAIDataForSubject(
        ptr<CscEntityReflexion> entityReflexion,
        const string &subject);
 
    ~CommandClearPublicAIDataForSubject() override;
 
protected:
    const CscCommandExecutionResultNone *doExecute(
        CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    string subject;
    ptr<CscEntityReflexion> entityReflexion;
};
COMMAND_REGISTER(CommandClearPublicAIDataForSubject, ptr<CscEntityReflexion>, const string &)
 
class CSC_DLL_IMPORTEXPORT CommandUpdateSensorValues : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "UPDATE_SENSOR_VALUES";
 
    CommandUpdateSensorValues(
        ptr<CscEntityReflexion> entityReflexion,
        const map<string, map<string, double>> &allSensors);
 
    ~CommandUpdateSensorValues() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    map<string, map<string, double>> allSensors;
};
COMMAND_REGISTER(CommandUpdateSensorValues, ptr<CscEntityReflexion>, const map<string, map<string, double>> &)
 
ENUM(CommandAutonomousExplorationInstruction,
     CommandAutonomousExplorationInstruction_Start,
     CommandAutonomousExplorationInstruction_Stop)
 
class CSC_DLL_IMPORTEXPORT CommandAutonomousExploration : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_AUTONOMOUS_EXPLORATION";
 
    CommandAutonomousExploration(
        ptr<CscEntityReflexion> entityReflexion,
        CommandAutonomousExplorationInstruction instruction);
 
    ~CommandAutonomousExploration() override;
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    CommandAutonomousExplorationInstruction instruction;
};
COMMAND_REGISTER(CommandAutonomousExploration, ptr<CscEntityReflexion>, CommandAutonomousExplorationInstruction)
 
struct CSC_DLL_IMPORTEXPORT CommandSmallMoveToBestDirectionOptions {
    optional<bool> rawYaw = nullopt;
 
    CommandSmallMoveToBestDirectionOptions(optional<bool> rawYaw = nullopt);
};
 
ENUM(CommandSmallMoveToBestDirectionInstruction,
     SmallMoveToBestDirectionInstruction_Start,
     SmallMoveToBestDirectionInstruction_Stop)
 
 
class CSC_DLL_IMPORTEXPORT CommandSmallMoveToBestDirection : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "SMALL_MOVE_TO_BEST_DIRECTION";
 
    CommandSmallMoveToBestDirection(
        ptr<CscEntityReflexion> entityReflexion,
        CommandSmallMoveToBestDirectionInstruction instruction,
        const CommandSmallMoveToBestDirectionOptions *options = nullptr);
 
    ~CommandSmallMoveToBestDirection() override;
 
    void stop();
 
protected:
    const CscCommandExecutionResultString *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
    CommandSmallMoveToBestDirectionInstruction instruction;
    const CommandSmallMoveToBestDirectionOptions *options = nullptr;
 
    inline static map<string, bool> startedBySerialNumber;
    inline static mutex startedBySerialNumberMutex;
    bool isStarted();
 
    const CscSize3d robotDimensionsConscienceRefFrame;
    const CscSize2d robotDimensionsMrpt;
 
    string bestDirectionName = "";
    void moveToBestDirection(const vector<CscAvailableDirection> &authorizedDirections, CscEnvironmentSimulator &environmentSimulator);
};
COMMAND_TYPE_BUILDER(CommandSmallMoveToBestDirection, CommandSmallMoveToBestDirectionOptions, bool)
COMMAND_REGISTER(CommandSmallMoveToBestDirection, ptr<CscEntityReflexion>, CommandSmallMoveToBestDirectionInstruction, const CommandSmallMoveToBestDirectionOptions *)
 
struct CSC_DLL_IMPORTEXPORT LidarLiveScanCommandDataType {
    LidarLiveScanCommandDataType(
        const vector<CscPoint3d *> &scanPoints,
        unsigned long long timestamp,
        const optional<OdometryData> &odometry);
 
    virtual ~LidarLiveScanCommandDataType();
 
    vector<CscPoint3d *> scanPoints;
    unsigned long long timestamp;
    optional<OdometryData> odometry = {};
};
class CSC_DLL_IMPORTEXPORT CommandEntityLidarScanGet : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "ENTITY_LIDARSCAN_GET";
 
    CommandEntityLidarScanGet(ptr<CscEntityReflexion> entityReflexion);
 
    ~CommandEntityLidarScanGet() override;
 
protected:
    const CscCommandExecutionResultObject<LidarLiveScanCommandDataType> *doExecute(CscEnvironmentSimulator &environmentSimulator) override;
    ptr<CscEntityReflexion> getEntityReflexion() const override;
 
private:
    ptr<CscEntityReflexion> entityReflexion;
};
COMMAND_REGISTER(CommandEntityLidarScanGet, ptr<CscEntityReflexion>)
COMMAND_RESULT_JSON_SERIALIZER(OdometryData, deltaPositionX, deltaPositionY, deltaPositionZ, deltaYaw)
COMMAND_RESULT_JSON_SERIALIZER(LidarLiveScanCommandDataType, scanPoints, timestamp, odometry)
 
}
 
#endif