CscEntityReflexion.h

Go to the documentation of this file.

//
//  CscEntityReflexion.hpp
//  ConscienceRobotManager
//
//  Created by Iliès Zaoui on 25/11/2020.
//  Copyright © 2018 IliesZaoui. All rights reserved.
//
 
#ifndef CscEntityReflexion_h
#define CscEntityReflexion_h
 
#include "CscCommon.h"
 
#include "CscEntitySensorValues.h"
#include "Lidar/CscPlaceCartography.h"
 
#include <ArtificialIntelligence/CscDetectionStats.h>
#include <ArtificialIntelligence/CscEntityClient.h>
#include <ArtificialIntelligence/alerts.h>
#include <DetectorEngine/CscCommonDetectorTypes.h>
#include <DetectorEngine/CscPublicAIData.h>
#include <Lidar/CscLidarEngine.h>
#include <Util/VisionDetectionLogger/VisionDetectionLogger.h>
#include <Util/json.h>
#include <thread>
#include <shared_mutex>
 
#pragma region forwardDefs
class CscEntityModel;
class CscState;
class CscSequence;
namespace conscience_core::core_objects {
}
namespace conscience_core::knowledge {
enum CscArtificialIntelligenceType : uint64_t;
class CscKnowledgeItem;
}
namespace cv {
class Mat;
};
namespace conscience_core::lidar {
class CscSlamEngine;
class CscEntityPositionManager;
}
namespace conscience_core::sequences_processor {
class CscSequencesProcessor;
}
class CscEnvironmentSimulator;
namespace conscience_utils::async {
class CscTimer;
}
namespace conscience_core::media_capture {
class CscEntityVideoSource;
class CscCaptureEngine;
class CscCaptureFileRecorder;
class CscCaptureFileRecorder;
}
namespace conscience_core::ai {
class CscMrptAutonomousExploration;
}
#pragma endregion forwardDefs
 
using namespace conscience_core::detector_engine;
using namespace conscience_core::core_objects;
using namespace conscience_core::ai;
using namespace conscience_core::media_capture;
using namespace conscience_core::lidar;
using namespace conscience_core::knowledge;
using namespace conscience_utils;
using namespace conscience_utils::detection_logger;
using namespace conscience_utils::JSON;
using namespace conscience_core::ai::alerts;
 
using namespace conscience_core::ai::data;
using namespace conscience_core::sequences_processor;
using namespace conscience_utils::async;
 
using std::prev, std::thread, std::recursive_mutex, std::chrono::system_clock, std::chrono::duration, std::remove_if, std::chrono::duration_cast, std::chrono::milliseconds, std::function;
using std::shared_mutex, std::chrono_literals::operator""s, std::chrono_literals::operator""ms, std::chrono_literals::operator""h;
 
namespace conscience_core::ai {
class CscSimulationWorld;
class TrackedObject;
struct CSC_DLL_IMPORTEXPORT TrackHit;
class CscEntityAlertIdentificationState;
class CscEntityDetectionState;
 
struct CSC_DLL_IMPORTEXPORT CaptureDetectFocusLoopConfiguration {
    float offsetTop;
    float offsetRight;
 
    CaptureDetectFocusLoopConfiguration(float theOffsetTop, float theOffsetRight) {
        offsetTop = theOffsetTop;
        offsetRight = theOffsetRight;
    }
};
 
struct CSC_DLL_IMPORTEXPORT CscEntityIdentity {
public:
    CscEntityIdentity(string name, string birthday);
    const string name;
    const string birthday;
};
 
class CSC_DLL_IMPORTEXPORT CscEntityReflexionParameters {
public:
    const string modelId;
    const string serialNumber;
    const ptr<CscEntityVideoSource> videoSource;
 
    CscEntityReflexionParameters(string serialNumber, string modelId, ptr<CscEntityVideoSource> videoSource, bool useGnssPositioning = false, optional<ptr<CscEntityIdentity>> entityIdentity = {}, optional<string> localProjection = {}, ptr<CscEntityClient> entityClient = nullptr, bool physicsRequiresAdditionalInit = false, optional<PositionFormat> simulatedInputsType = {});
    static ptr<CscEntityReflexionParameters> create(string serialNumber, string modelId, ptr<CscEntityVideoSource> videoSource, bool useGnssPositioning = false, optional<ptr<CscEntityIdentity>> entityIdentity = {}, optional<string> localProjection = {}, ptr<CscEntityClient> entityClient = nullptr, optional<PositionFormat> simulatedInputsType = {});
    const bool useGnssPositioning;
    operator string() const;
    string serialize() const;
    CscJsonObject *serializeJson() const;
    bool equals(const CscEntityReflexionParameters &other) const;
    static ptr<CscEntityReflexionParameters> fromSerialized(const string &serialized);
    static ptr<CscEntityReflexionParameters> fromSerializedJson(CscJsonObjectReader &serialized);
    ptr<CscEntityIdentity> getEntityIdentity() const;
    ptr<CscEntityClient> getEntityClient() const;
    void setEntityClient(ptr<CscEntityClient> client);
    bool isSimulated() const;
    bool doesPhysicsRequireAdditionalInit() const;
    const optional<PositionFormat> simulatedInputsType;
    const optional<string> localProjection;
 
private:
    ptr<CscEntityIdentity> entityIdentity;
    ptr<CscEntityClient> entityClient;
    bool physicsRequiresAdditionalInit;
};
 
class CSC_DLL_IMPORTEXPORT CscEntityReflexionDetectionParameters {
public:
    struct CSC_DLL_IMPORTEXPORT DetectionNotificationParameters {
 
        optional<string> protocol;
        optional<string> host;
        optional<string> pathPrefix = "";
        optional<int> port;
        bool uploadVideo;
        int periodMilliseconds;
        int videoDurationMillis;
        vector<string> vocalNotificationPhoneNumbers;
        vector<string> emailAddresses;
 
        int getPort() const;
        operator string() const;
 
        bool hasBackendNotification() const;
    };
 
    const vector<ConscienceDetectorType> detectors;
 
    const vector<ptr<const CscAlertIdentificationConfig>> alerts;
 
    const vector<CscDetectionStatsType> stats;
 
    const bool shouldFocusDetections;
    const optional<DetectionNotificationParameters> notificationParameters;
    const bool locateInSimulator;
    const optional<bool> waitForFirstResult;
    CscDetectorEngine *const detector = nullptr;
 
    const map<string, string> additionalParams;
 
    CscEntityReflexionDetectionParameters(const vector<ConscienceDetectorType> &detectors = {},
                                          const vector<ptr<const CscAlertIdentificationConfig>> &alerts = {},
                                          const vector<CscDetectionStatsType> &stats = {},
                                          bool shouldFocusDetections = false,
                                          const optional<DetectionNotificationParameters> &notificationParameters = {},
                                          bool locateInSimulator = true,
                                          const map<string, string> &additionalParams = {},
                                          CscDetectorEngine *detector = nullptr);
 
    bool isNotificationEnabled() const;
 
    bool isStop() const;
 
    bool shouldVisionBeEnabled() const;
    bool doesAlertTypeNeedVision(CscAlertType alertType) const;
 
    operator string() const;
    string toString() const;
};
 
struct CSC_DLL_IMPORTEXPORT VisionDetectionTargetObjectOffset {
    float offsetTop;
    float offsetRight;
};
 
struct CSC_DLL_IMPORTEXPORT LiveEnvironmentDetectedObject {
    string objectId;
    int objectModelId;
    CscPoint3d position;
    CscPoint3d rotation;
    double certitude;
    unsigned long long immobileSinceMilliseconds;
 
    LiveEnvironmentDetectedObject(const string &objectId,
                                  int objectModelId,
                                  const CscPoint3d &position,
                                  const CscPoint3d &rotation,
                                  double certitude,
                                  unsigned long long immobileSinceMilliseconds);
};
 
typedef function<void(bool accept)> Answer;
struct CSC_DLL_IMPORTEXPORT HumanDecision {
public:
    const string uid;
    const string message;
    bool obsolete = false;
    HumanDecision(const string &uid, const string &message, const Answer &answer);
    operator string() const;
    void answer(bool accept);
    optional<bool> getAnswer() const;
 
private:
    const Answer answerFunction;
    optional<bool> result = {};
};
 
enum FocusType {
    INVERSE_KINEMATIC = 0,
    PAN_TILT = 1
};
 
struct CSC_DLL_IMPORTEXPORT IkFocusParam {
    int stationaryPivotId;
    int memberIdToMove;
};
 
struct CSC_DLL_IMPORTEXPORT FocusParameter {
    FocusType focusType;
    optional<IkFocusParam> ikParam = {};
 
    FocusParameter(FocusType focusType, IkFocusParam ikParam) : focusType(focusType), ikParam(ikParam) {}
};
 
typedef function<void(vector<ptr<const LiveEnvironmentDetectedObject>> detectedObjects)> LiveEnvironmentUpdateListener;
typedef function<void(CscSequence *sequence)> SequenceProcessorSendSequenceListener;
 
struct CSC_DLL_IMPORTEXPORT CscEntityReflexionActivity {
    unsigned fps = 0;
    unsigned long long lastFrameTimestampMillis = 0;
    string activeDetectionDescription = "";
    string enabledAlertsDescription = "";
};
 
typedef uint64_t CscEntityStatusFlags;
enum CscEntityStatusFlagsList : CscEntityStatusFlags {
    // the status is implemented on 64 bit , so 64 statuses are available
    // if change, add or update state , think to update connect entityStatus
    NONE = 0,
    READY = 1ULL << 0,
    CONSCIENCE_START = 1ULL << 1,
    WAITING_CLIENT_CONNECTION = 1ULL << 2,
    POSITION_ACCURACY_TOO_LARGE = 1ULL << 3,
    RECEIVE_MESSAGE = 1ULL << 4,
    SEND_MESSAGE_CHUNKED = 1ULL << 5,
    PROCESS_COMMAND = 1ULL << 6,
    SEND_TCP_MESSAGE = 1ULL << 7,
    RECIEVE_ENGINE_RESPONSE = 1ULL << 8,
    CHECKING_UPGRADE = 1ULL << 9,
    UPGRADE_IN_PROGRESS = 1ULL << 10,
    OBSTACLE_IN_RANGE = 1ULL << 11,
    POSITION_MANAGER_NOT_READY = 1ULL << 12,
    SEQUENCE_PROCESSOR_SEQUENCE_IN_PROGRESS = 1ULL << 13,
    SEQUENCE_PROCESSOR_SEQUENCE_IN_PAUSE = 1ULL << 14,
    SEQUENCE_PROCESSOR_SEQUENCE_UPLOADING = 1ULL << 15,
    SEQUENCE_PROCESSOR_SEQUENCE_TERMINATE = 1ULL << 16,
    ENTITY_BLOCKED_GYRO = 1ULL << 17,
    ENTITY_BLOCKED_GPS = 1ULL << 18,
    ENTITY_DISTANT_REALITY_MOVE = 1ULL << 19,
    ENTITY_BLOCKED_OBSTACLES = 1ULL << 20,
 
    ENTITY_EXPLORATION_RESTORE_MOVE = 1ULL << 61,
    ENTITY_EXPLORATION_NO_FRONTIERS = 1ULL << 62,
};
 
static const vector<CscEntityStatusFlagsList> ENTITY_STATUSES_BLOCKED = {CscEntityStatusFlagsList::ENTITY_BLOCKED_GYRO, CscEntityStatusFlagsList::ENTITY_BLOCKED_GPS, CscEntityStatusFlagsList::ENTITY_BLOCKED_OBSTACLES};
 
class CSC_DLL_IMPORTEXPORT CscEntityReflexion {
public:
    CscEntityReflexion(
        ptr<CscEntityReflexionParameters> parameters,
        CscEnvironmentSimulator &globalEnvironmentSimulator);
 
    virtual ~CscEntityReflexion();
 
    void stopAndRelease(bool removeFromEnvironment = true);
 
    map<string, EntitySensorValues> getAllSensorValuesBySensorName();
    void setSensorValues(const string &sensorName, const map<string, double> &values);
    bool isLidarEngineActivated();
    bool isLidarEngineInitialized();
 
    string getEntityType(const CscEntityModel &model) const;
 
    void restoreCartography(optional<fs::path> cartographyDirMaybe = {});
    CscPlaceCartography *getCartography() const;
 
    void setScene(CscWorldPlace *place);
 
    CscCaptureEngine *getCaptureEngine(const optional<string> &videoSourceId = {}) const;
 
    void resetToInitialState();
    ptr<CscEntityReflexion> getSharedPtr() const;
 
    void consumeVideoSource(const optional<string> &id = {}, bool reopenEvenIfAlreadyOpened = true);
 
    void setVideoSource(ptr<CscEntityVideoSource> videoSource, bool consumeIfClosedOrSourceChanged = false);
 
    void resetParameters(ptr<CscEntityReflexionParameters>);
 
    ptr<const CscEntityReflexionParameters> getParameters() const;
 
    ptr<CscEntityReflexionDetectionParameters> getDetectionParameters();
    void setDetectionParameters(ptr<CscEntityReflexionDetectionParameters>);
 
    void unwatchAlerts(const vector<CscAlertType> &alertsToBeUnwatched);
    vector<CscDetectedAlert> getAlerts();
    void addAlert(CscDetectedAlert *newIdentifiedAlert);
    void markAlertDone(const AlertId &alertId);
    bool isAlertDone(const AlertId &alertId);
    void setAlertsMaxAgeMillis(long alertsMaxAgeMillis);
 
    void fireLiveEnvironmentUpdate();
 
    ptr<CscEntityClient> getEntityClient() const;
 
    optional<ptr<DetectionResult>> getLastDetectionResult();
 
    CscEnvironmentSimulator &getGlobalEnvironmentSimulator();
 
    void addLiveEnvironmentUpdateListener(LiveEnvironmentUpdateListener listener);
    void onSequenceToBeSentToRealEntity(SequenceProcessorSendSequenceListener listener);
 
    const string &getSerialNumber() const;
    const string &getEntityModelId() const;
 
    optional<fs::path> stopLastPeriodCaptureRecordingToFile();
 
    void startLastPeriodCaptureRecordingToFile(short durationSeconds, const fs::path &outputPath);
 
    void stopCaptureRecordingToFile();
 
    void startCaptureRecordingToFile(const fs::path &outputPath, const optional<string> &videoSourceId = {});
 
    void purgeAIObjectives();
 
    const CscEntityModel *getEntityModel() const;
 
    const CscSimulationWorld *getAISimulationWorld() const;
 
    float *geAIObjectivesStatus() const;
 
    CscSequence *processKnowledgeItem(CscKnowledgeItem *knowledgeItem, CscState *initialState);
 
    void stopLidarEngine();
    void startLidarEngineLocalDevice(string devicePath, double *currentState);
    void startLidarEngineEntity();
    optional<string> getStringDetectorResult();
    void clearStringDetectorResult();
 
    void vocalPhoneCallTest(const vector<string> &phoneNumbers, const map<string, string> &additionalParams);
 
    void removeObjectivesByAITypes(knowledge::CscArtificialIntelligenceType type);
 
    void setSlamCartographyActivated(bool enable);
    void stopAndSaveLidarCartography();
 
    void setSlamLocalizationActivated(bool enable, CscPoint3dOriented *position = nullptr);
 
    void clearLidarCartography();
 
    CscEntityPositionManager *getPositionManager() const;
 
    vector<ptr<HumanDecision>> getOngoingDecisions();
    void answerDecision(const string &decisionUid, bool accept);
 
    const FocusParameter *getFocusParameter();
    void setFocusParameter(const FocusParameter *focusParam);
 
    map<string, ptr<CscPublicAIData>> getPublicAIDataForSubject(const string &subject);
    void clearPublicAIDataForSubject(const string &subject);
 
    CscSequencesProcessor *getSequenceProcessor() const;
    CscSlamEngine *getSlamEngine();
    CscLidarEngine *getLidarEngine();
 
    bool isSimulated() const;
 
    bool useGnssPositioning() const;
 
    ptr<CscEntityIdentity> getEntityIdentity() const;
 
    void sendSequenceToRealRobot(CscSequence *sequence) const;
 
    void ifRunning(function<void()> action);
 
    void loadCartographyFromPoints(const vector<const CscPoint3d *> &points);
 
    const vector<ptr<CscEntityVideoSource>> &getVideoSources() const;
 
    ptr<CscEntityVideoSource> getVideoSource(const optional<string> &id = {}) const;
 
    void addVideoSource(ptr<CscEntityVideoSource> videoSource);
 
    void removeVideoSource(ptr<CscEntityVideoSource> videoSource);
 
    static bool &autoCloseStreamEnabled();
 
    CscEntityReflexionActivity getActivitySummary();
 
    ptr<CscEntityDetectionState> getDetectionState() const {
        return detectionState;
    }
    CscEntityStatusFlags getAllEntityStatusFlags() const;
    bool hasStatusFlag(const vector<CscEntityStatusFlagsList> &statuses) const;
    bool hasStatusFlag(CscEntityStatusFlagsList status) const;
 
    void setLastEntityStatusFlags(const string &lastEntityStatusFlags);
 
    void addAdditionalEntityStatusFlag(CscEntityStatusFlagsList flag);
    void removeAdditionalEntityStatusFlag(CscEntityStatusFlagsList flag);
 
    void startAutonomousExploration();
    void stopAutonomousExploration();
 
    void setEntityClient(ptr<CscEntityClient> entityClient);
 
    void ifNotStopped(const function<void()> &action);
 
    void addCustomData(const map<string, void *> &customData);
    map<string, void *> getCustomData() const;
    void *getCustomDataValue(const string &key) const;
 
    void *eraseCustomData(const string &key);
 
    template <typename T>
    optional<T> getCustomDataValueCopy(const string &key) const {
        std::shared_lock lock(customDataMutex);
        T *result = nullptr;
        auto valueMatch = customData.find(key);
        if (valueMatch != customData.end()) {
            result = static_cast<T*>(valueMatch->second);
        }
        return result == nullptr ? nullopt : optional<T>(*result);
    }
 
 
 
    bool isStopping() const;
 
private:
    CscEntityStatusFlags lastEntityStatusFlags = 0;
    CscEntityStatusFlags additionalEntityStatusFlags = 0;
    void addPublicAIDataFromTrackedObjects(map<string, map<string, CscPublicAIData *>> &updatedPublicAIData);
 
    map<string, EntitySensorValues> sensorValuesBySensorName;
    shared_mutex sensorValuesMutex;
 
    inline bool shouldTriggerNotificationsInstantly() const { return getSerialNumber() == "8"; }
    bool loopRunning = false;
    unsigned loopTerminatedCount = 0;
    thread reflexionThread;
    ptr<CscEntityReflexion> *thisPtr;
    void identifyDetectionAlerts();
    optional<string> stringDetectorResult = {};
    unsigned long lastCartographyActivityMillis = 0;
    const long loadCartographyLogIntervalMillis = 15000;
    bool previousCartographyDetected = false;
 
    void captureDetectLoopTick();
 
    unsigned long long cartographyOccupiedCellsLastRefreshTimeMillis;
 
    vector<ptr<CscEntityVideoSource>> videoSources;
 
    CscSimulationWorld *AISimulationWorld;
    void startAI();
    void AILoopTick();
    recursive_mutex captureDetectMutex;
    int processKnowledgeRequestsCount = 0;
 
    vector<LiveEnvironmentUpdateListener> liveEnvironmentListeners;
    vector<SequenceProcessorSendSequenceListener> sequenceToBeSentToRealEntityListeners;
 
    optional<ptr<DetectionResult>> lastDetectionResult = {};
 
    thread *captureDetectThread = nullptr;
 
    ptr<CscEntityReflexionParameters> parameters;
    ptr<CscEntityReflexionDetectionParameters> detectionParameters = nullptr;
 
    CscLidarEngine *lidarEngine = nullptr;
    CscSlamEngine *slamEngine = nullptr;
 
    CscEnvironmentSimulator &globalEnvironmentSimulator;
    CscEntityPositionManager *positionManager = nullptr;
 
    void focusClosestDetectedObject();
    optional<int> currentFocusedObjectId = {};
 
    CscCaptureEngine *captureEnginePrimary = nullptr;
    map<string, CscCaptureEngine *> secondaryCaptureEngines;
    ptr<CscCaptureFileRecorder> lastPeriodCaptureFileRecorder = nullptr;
    mutex captureFileRecorderMutex;
    ptr<CscCaptureFileRecorder> fileRecorder = nullptr;
 
    CscPlaceCartography *currentPlaceCartography = nullptr;
    mutable mutex currentPlaceCartographyMutex;
 
    const FocusParameter *focusParameter = nullptr;
 
    // TODO : move in detection parameters
    CaptureDetectFocusLoopConfiguration currentCaptureDetectFocusLoopConfiguration = CaptureDetectFocusLoopConfiguration(0, 0);
    VisionDetectionLogger *cscVisionDetectionLogger;
 
    CscDetectorEngine *detector = nullptr;
    void resolveDetector();
    inline bool isDetectionEnabled() const { return detector != nullptr; }
 
    vector<CscDetectorEngine *> detectorsToBeDeleted;
    milliseconds trackingMaxAbsenceDuration = 2000ms;
    milliseconds trackingMaxActualDetectionMissingDuration = 6000ms;
 
    bool isAlertEnabled(CscAlertType type) const;
    ptr<const CscAlertIdentificationConfig> getAlertConfig(CscAlertType type) const;
 
    vector<CscDetectionStatsType> enabledStatsTypes;
 
    ptr<DetectionResult> performDetectionOnImage(const cv::Mat &currentFrame, cv::Mat &resultingImage);
 
    void startLoops();
 
    void reflexionThreadLoop();
 
    void cartographyAndLocalizationProcess();
 
    int detectionFrameId = 0;
 
    optional<unsigned long long> streamOpenWithDetectionOffStartTimeMillis = {};
 
    CscTimer *lastSuccessfulDetectionTimer = nullptr;
    struct CSC_DLL_IMPORTEXPORT VisionDetectionTargetObjectOffset visionDetectionTargetObjectOffset;
 
    CscState *initialState;
 
    const string detectionResultImagesDirectoryPath = "";
 
    bool autobackToInitialStateEnabled = false;
 
    const LenseParameter *getLenseParameters() const;
 
    cv::Mat *lastFrame = nullptr;
    unsigned long long lastFrameTimeMillis = 0;
    unsigned fps = 0;
    unsigned fpsFramesCount = 0;
    unsigned long long lastFpsRefreshMillis = 0;
    bool streamUnavailabilityNotified = true;
 
    unique_ptr<CscLogger> logger;
 
    system_clock::time_point lastFocusStateTime = system_clock::now();
 
    /* end of TrackedObject */
 
    map<CscDetectionStatsType, double> gatherDetectionStats();
 
    system_clock::time_point lastAlertIdentificationTime = system_clock::now() - 12h;
    map<AlertId, CscDetectedAlert *> alerts;
    long alertsMaxAgeMillis = 12 * 60 * 60 * 1000;
    shared_mutex alertsMutex;
 
    void purgeOldAlerts();
    vector<AlertId> getAlertIds(vector<ptr<CscDetectedAlert>> alerts);
    system_clock::time_point lastNotificationsCheckTime = system_clock::now() - 12h;
    unsigned long long lastLidarCartographyTimeMillis = 0;
    unsigned long long lastTimeLoggedLidarLossTimeMillis = 0;
    size_t lastRenderedSceneMatrixSize = 0;
 
    map<AlertId, system_clock::time_point> alertNotificationTimes;
 
    void notifyDetections();
 
    void notifyDetectionsThreadAction(const vector<CscDetectedAlert> &alerts, map<CscDetectionStatsType, double> stats, fs::path videoPath, CscEntityReflexionDetectionParameters::DetectionNotificationParameters notificationParameters);
 
    void resetEntityToInitialStateIfDetectionTimeout(ptr<DetectionResult> &detectionResult);
    void updateCurrentAlerts(map<AlertId, CscDetectedAlert *> currentAlerts);
 
    void logVisionDetection(const ptr<DetectionResult> &detectionResult);
 
    void updateSimulator(const vector<ptr<TrackedObject>> &removedObjects);
 
    void showLidarLocalizationInEnvironment(const CscPoint3d *estimatedPosition, float eulerY);
 
    mutex stopMutex;
    bool isStoppingValue = false;
 
    mutex ongoingDecisionsMutex;
    map<string, ptr<HumanDecision>> ongoingDecisions;
    ptr<HumanDecision> addDecision(
        const string &message, Answer answer = [](bool accepted) {});
    void removeDecision(const string &decisionUid);
    int lastDecisionUid = 0;
    ptr<CscEntityDetectionState> detectionState = nullptr;
    bool trackingEnabled = false;
    void filterAlertsOnTimeSlots(map<AlertId, CscDetectedAlert *> &alerts);
    vector<ptr<const CscAlertIdentificationConfig>> enabledAlerts;
 
    map<string, map<string, CscPublicAIData *>> publicAIData;
    shared_mutex publicAIDataMutex;
    void updatePublicAIData(const map<string, map<string, CscPublicAIData *>> &updatedPublicAIData);
 
    CscSequencesProcessor *sequencesProcessor = nullptr;
    const string logPrefix;
 
    CscPoint3dOriented *getOdometryEstimatedPositionFromLastPosition(const CscPoint3dOriented *lastPosition);
 
    CscMrptAutonomousExploration *autonomousExploration = nullptr;
 
    bool isUsingAiApi = false;
 
    map<string, void *> customData;
    mutable shared_mutex customDataMutex;
};
}
 
#endif