CommandGenerateCompletePath.h

Go to the documentation of this file.

#ifndef CommandGenerateCompletePath_h
#define CommandGenerateCompletePath_h
 
#include "./Command.h"
 
#include <memory>
#include "./Result/CommandExecutionResultNone.h"
#include <opencv2/opencv.hpp>
 
#include "ArtificialIntelligence/CscEntityReflexion.h"
#include "Parser/CscCommandAutoParse.h"
 
using namespace conscience_core::ai;
using namespace conscience_utils;
 
namespace fs = std::filesystem;
using std::ceil, std::map, std::pair, std::make_pair, std::max, std::floor, std::numeric_limits, std::optional, std::array, std::string, std::vector, std::unique_ptr;
 
namespace conscience_core::bridging::commands {
 
class CSC_DLL_IMPORTEXPORT CommandGenerateCompletePath : public CscCommand {
        
    public:
        inline static const CommandTypeId COMMAND_ID = "GENERATE_COMPLETE_PATH_FOR_SCENE";
 
        CommandGenerateCompletePath(ptr<CscEntityReflexion> entityReflexion, optional<float> tileSizeCmMaybe, optional<CscArea3d*> area, optional<string> placeId);
        virtual ~CommandGenerateCompletePath() = default;
        
    protected:
        const CscCommandExecutionResultSequence * doExecute(CscEnvironmentSimulator &environmentSimulator) override;
        
        ptr<CscEntityReflexion> getEntityReflexion() const override {
            return entityReflexion;
        }
        
    private:
        std::unique_ptr<CscLogger> logger;
        ptr<CscEntityReflexion> entityReflexion;
        optional<string> placeId = {};
 
        bool areaDefined = false;
        CscArea3d area;
        CscArea3d areaPlace;
        float tileSizeCm = 100.0f;
        const float BEST_PATH_POINTS_HEIGHT_CM = 10;
        
        vector<CscPoint3dOriented *> bestPath;
        int columnsCount = 0;
        int tilesPerColumnCount = 0;
 
        float tileWidth = 0;
        float tileHeight = 0;
        
        int inaccessibleTilesCount = 0;
        int visitedOnceTilesCount = 0;
        int allVisitedTilesCount = 0;
        CscLocationTag* base = nullptr;
        void computeBaseTile();
 
        
        struct CSC_DLL_IMPORTEXPORT Tile {
        public:
            const int indexX;
            const int indexY;
            
            bool visited = false;
            bool accessible;
            vector<int> visitsIndices;
            
            Tile(int indexX,
                 int indexY,
                 bool accessible) :indexX(indexX), indexY(indexY),accessible(accessible) {
                
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT ColumnChunkCrossroad {
        public:
            const int remoteChunkIndexInColumn;
            const int y;
            const int tileIndexInRemoteChunk;
            const bool left;
            bool disabled = false;
            
            ColumnChunkCrossroad(int remoteChunkIndexInColumn,
                                 int y,
                                 int tileIndexInRemoteChunk,
                                 bool left) :
                remoteChunkIndexInColumn(remoteChunkIndexInColumn), y(y),tileIndexInRemoteChunk(tileIndexInRemoteChunk), left(left) {
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT ColumnChunk {
        public:
            vector<Tile *> tiles;
            
            int yMin = -1;
            int yMax = -1;
            
            vector<ColumnChunkCrossroad *> pivotsLeft;
            vector<ColumnChunkCrossroad *> pivotsRight;
            
            bool allTilesVisited() {
                for (Tile * tile : tiles) {
                    if (!tile->visited) {
                        return false;
                    }
                }
                return true;
            }
        };
        
        struct CSC_DLL_IMPORTEXPORT Image {
        public:
            cv::Mat image;
            int imageHeight;
        };
        
        
        Image* mapImage = nullptr;
        CscPoint3d simulatorPlaceShift = CscPoint3d(0,0,0);
        ColumnChunkCrossroad * lastCrossRoad = nullptr;
        vector<vector<ColumnChunk>> columns;
        vector<vector<Tile *>> tiles;
        void processChunk(int ix, ColumnChunk & current, int currentTileIndexInChunk);
        
        pair<int, int> lastTile = make_pair(-1, -1);
        void addToBestPath(int tileX, int tileY);
        
        void initializeDimensions();
        void generateTiles();
        bool computeAccessibleTiles(float x2D, float y2D, float height);
        bool computeAccessibleTilesCartography(vector<CscPoint3d*> *placeVertices);
        bool computeAccessibleTilesPlace(vector<const CscPoint3d*> *placeVertices);
        bool initTilesFromPlace(CscWorldPlace *place, CscEnvironmentSimulator &environmentSimulator);
        
        void addPathToTargetToBestPath(int tileX, int currentTileY, int targetTileY);
        void enterCrossroad(int currentColumnIndex, ColumnChunkCrossroad * crossroad);
        void freeMemory();
        CscSequencePositions * entityTo(CscEnvironmentSimulator &, CscPoint3d*);
        CscSequencePositions* backToBase(CscEnvironmentSimulator &environmentSimulator, string target, CscPoint3d* lastPosition);
 
    };
 
COMMAND_REGISTER(CommandGenerateCompletePath, ptr<CscEntityReflexion>, optional<float>, optional<CscArea3d*>, optional<string>)
}
 
#endif