CommandAreaAnalysis.h

Go to the documentation of this file.

 
#ifndef CommandAreaAnalysis_h
#define CommandAreaAnalysis_h
 
#include <limits>
#include <unordered_map>
#include <unordered_set>
 
#include "./ArtificialIntelligence/CscEntityReflexion.h"
#include "./Command.h"
#include "Parser/CscCommandAutoParse.h"
 
#define DOUBLE_PRECISION 0.001
// MAXIMUM_RATIO is used to limit the number of points in the sequence returned at the end of the command. If the number of points is too much (660 000 points in the sequence was too much during tests, 130 000 points was not), the result was an error failed to parse
#define MAXIMUM_RATIO 200000
#define MIN_DIST 50
 
using std::vector, std::unordered_map, std::unordered_set;
 
namespace conscience_core::bridging::commands {
class CSC_DLL_IMPORTEXPORT CommandAreaAnalysis : public CscCommand {
 
public:
    inline static const CommandTypeId COMMAND_ID = "AREA_ANALYSIS";
    CommandAreaAnalysis(ptr<CscEntityReflexion> entityReflexion, vector<const CscPoint3d *> areaVertices, vector<vector<const CscPoint3d *>> holes, double areaOfPerceptionWidth, const CscPoint3d *entityPosition, optional<bool> doNotPlay);
    ~CommandAreaAnalysis() override;
 
protected:
    ptr<CscEntityReflexion> entityReflexion;
    ptr<CscEntityReflexion> getEntityReflexion() const override {
        return entityReflexion;
    }
    const CscCommandExecutionResultSequence * doExecute(CscEnvironmentSimulator &environmentSimulator) override;
 
private:
 
    bool doNotPlaySequence = false;
    CscEnvironmentSimulator *envi;
    struct CSC_DLL_IMPORTEXPORT Polygon;
    struct CSC_DLL_IMPORTEXPORT Vertex;
    struct CSC_DLL_IMPORTEXPORT Endpoint;
    struct CSC_DLL_IMPORTEXPORT Edge;
    struct CSC_DLL_IMPORTEXPORT Cell;
    struct CSC_DLL_IMPORTEXPORT EdgeCell;
    struct CSC_DLL_IMPORTEXPORT CellGraph;
    struct CSC_DLL_IMPORTEXPORT CellAdjacentList;
    struct CSC_DLL_IMPORTEXPORT PriorityCell;
    struct CSC_DLL_IMPORTEXPORT Tile;
    struct CSC_DLL_IMPORTEXPORT Area;
 
    vector<const CscPoint3d *> areaVertices;
    vector<vector<const CscPoint3d *>> holes;
    vector<vector<CommandAreaAnalysis::Tile *>> tiles;
    double areaOfPerceptionWidth;
    const CscPoint3d *entityPosition;
 
    vector<CscPoint3d *> tilePathToPointPath(vector<CommandAreaAnalysis::Tile *> tilePath, const CscPoint3d *bottomLeftCorner);
 
    CscSequencePositions *generateSequenceWithPositions(CscEnvironmentSimulator &environmentSimulator, vector<CscPoint3d *> positions);
    vector<CscPoint3d *> filterPointInsidePolygon(vector<CscPoint3d *> toFilter);
 
    void trapezoidalDecomposition(CommandAreaAnalysis::Area polygon, double tileSideLength, vector<Polygon *> &cells, vector<Edge *> edges);
 
    void processEvent(CommandAreaAnalysis::Area polygon, double tileSideLength, Vertex *eventVertex, vector<Edge *> edges, vector<Polygon *> &cells, vector<Vertex *> vertices);
 
    vector<CscPoint3d *> explore(vector<CommandAreaAnalysis::Cell *> spanningTree, vector<Cell *> graphCells, CommandAreaAnalysis::Area polygon, double tileSideLength, CommandAreaAnalysis::Cell *firstCell, vector<Edge *> edges);
 
    void showPointPathOnSceneFloor(vector<CscPoint3d *> sequence, CscEnvironmentSimulator &environmentSimulator, bool clear, bool line);
    void createAreaTiles(int numberOfLines, int numberOfColumns, const CscPoint3d *firstPoint, CommandAreaAnalysis::Polygon polygon);
    void freeMemory();
 
    static bool isFirstBeforeSecond(const CscPoint3d *first, const CscPoint3d *second);
 
    static bool equalsTwoDouble(double lhs, double rhs);
    static bool equalsTwoPoints(const CscPoint3d *lhs, const CscPoint3d *rhs);
    static void siftDown(const CscPoint3d *lexicalOrder[], int length, int i);
 
    static void heapSort(const CscPoint3d *lexicalOrder[], int length);
 
    static CscPoint3d *convertTileToPoint(Tile *tile, const CscPoint3d *firstPoint, double areaOfPerceptionWidth);
 
    static CommandAreaAnalysis::Polygon *createTrapezoid(const CscPoint3d *first, const CscPoint3d *second, const CscPoint3d *third, const CscPoint3d *fourth, CscEnvironmentSimulator *envi);
 
    struct CSC_DLL_IMPORTEXPORT Area {
    private:
        vector<Polygon *> forbiddenAreas;
        vector<const CscPoint3d *> intersections;
        CscEnvironmentSimulator *envi;
 
    public:
        Polygon *areaToExplore;
 
        Area(Polygon *areaToExplore, vector<Polygon *> forbiddenAreas, double &areaOfPerceptionWidth, CscEnvironmentSimulator *envi);
 
        vector<const CscPoint3d *> areaVertices();
 
        vector<Edge *> getEdges();
 
        bool isPointInside(const CscPoint3d *pointToCheck);
 
        vector<const CscPoint3d *> getLexicalOrder();
 
        const CscPoint3d *getNearestVisibleVertex(vector<Vertex *> vertices, vector<Edge *> edges, const CscPoint3d *triggerVertex, const CscPoint3d *vertexEndPoint);
        bool isVertexVisible(vector<Edge *> edges, const CscPoint3d *triggerVertex, const CscPoint3d *otherVertex);
 
        Endpoint *getEndpoint(const CscPoint3d *vertex, double tileSideLength, vector<Edge *> edges, bool isAbove);
 
        Polygon *continueEvent(Vertex *triggerVertex, double tileSideLength, vector<Edge *> edges, vector<Vertex *> vertices);
 
        Polygon *mergeEvent(Vertex *triggerVertex, double tileSideLength, vector<Edge *> edges, vector<Vertex *> vertices);
 
        vector<Polygon *> outEvent(Vertex *triggerVertex, double tileSideLength, vector<Edge *> edges, vector<Vertex *> vertices);
 
        Polygon *splitEvent(Vertex *triggerVertex, double tileSideLength, vector<Edge *> edges, vector<Vertex *> vertices);
    };
 
    struct CSC_DLL_IMPORTEXPORT Tile {
    public:
        const int indexX;
        const int indexY;
        bool isVisited = false;
        bool accessible;
 
        Tile(int indexX,
             int indexY,
             bool accessible = true) : indexX(indexX), indexY(indexY), accessible(accessible) {}
    };
 
    struct CSC_DLL_IMPORTEXPORT Edge {
        const CscPoint3d *firstPoint;
        const CscPoint3d *secondPoint;
 
        Edge(const CscPoint3d *first, const CscPoint3d *second) : firstPoint(first), secondPoint(second) {}
 
        struct CSC_DLL_IMPORTEXPORT EdgeHash {
            std::size_t operator()(const Edge edge) const {
                std::string concat = std::to_string(edge.firstPoint->getX()) +
                                     std::to_string(edge.firstPoint->getZ()) +
                                     std::to_string(edge.secondPoint->getX()) +
                                     std::to_string(edge.secondPoint->getZ());
                return std::hash<std::string>()(concat);
            }
        };
 
        struct CSC_DLL_IMPORTEXPORT EdgeEqual {
            bool operator()(const Edge lhs, const Edge rhs) const {
                return (equalsTwoPoints(lhs.firstPoint, rhs.firstPoint) && equalsTwoPoints(lhs.secondPoint, rhs.secondPoint)) || (equalsTwoPoints(lhs.firstPoint, rhs.secondPoint) && equalsTwoPoints(lhs.secondPoint, rhs.firstPoint));
            }
        };
 
        const CscPoint3d *createEndPointOnEdge(const CscPoint3d *point);
        const CscPoint3d *intersect(Edge *other);
        bool isOnEdge(const CscPoint3d *point);
    };
 
    struct CSC_DLL_IMPORTEXPORT Endpoint {
        const CscPoint3d *point;
        Edge *edge;
 
        Endpoint(const CscPoint3d *point, Edge *edge) : point(point), edge(edge) {}
 
        ~Endpoint() {
            delete point;
        }
    };
 
    struct CSC_DLL_IMPORTEXPORT Vertex {
        const CscPoint3d *point;
        Edge *firstEdge;
        Edge *secondEdge;
 
        Vertex(const CscPoint3d *point, Edge *firstEdge, Edge *secondEdge) : point(point), firstEdge(firstEdge), secondEdge(secondEdge) {}
 
        struct CSC_DLL_IMPORTEXPORT VertexHash {
            size_t operator()(const Vertex *v) const {
                size_t h1 = std::hash<std::string>()(to_string(v->point->getX()) + to_string(v->point->getY()) + to_string(v->point->getZ()));
                return h1;
            }
        };
        struct CSC_DLL_IMPORTEXPORT VertexEqual {
            bool operator()(const Vertex *lhs, const Vertex *rhs) const {
                return equalsTwoPoints(lhs->point, rhs->point);
            }
        };
    };
 
    struct CSC_DLL_IMPORTEXPORT Polygon {
    public:
        CscEnvironmentSimulator *envi;
        vector<const CscPoint3d *> polygonVertices;
        vector<Edge *> edges;
 
        Polygon(vector<const CscPoint3d *> areaVertices, CscEnvironmentSimulator *envi) : polygonVertices(areaVertices), envi(envi) {
            int j = areaVertices.size() - 1;
            int i = 0;
            // creates edges of the polygon according to the position of vertices in the vector
            while (i < areaVertices.size()) {
                Edge *firstEdge;
                if (isFirstBeforeSecond(areaVertices.at(j), areaVertices.at(i))) {
                    firstEdge = new Edge(areaVertices.at(j), areaVertices.at(i));
                } else {
                    firstEdge = new Edge(areaVertices.at(i), areaVertices.at(j));
                }
                edges.push_back(firstEdge);
                j = i;
                i++;
            }
        }
 
        vector<const CscPoint3d *> getLexicalOrder();
 
        const CscPoint3d *getPointHighestX();
        const CscPoint3d *getPointHighestZ();
        const CscPoint3d *getPointLowestX();
        const CscPoint3d *getPointLowestZ();
        const CscPoint3d *getFirstPoint();
        vector<CommandAreaAnalysis::Tile *> boustrophedonPath(vector<vector<CommandAreaAnalysis::Tile *>> polygon, CscPoint3d *position);
        vector<vector<CommandAreaAnalysis::Tile *>> getTranspose(vector<vector<CommandAreaAnalysis::Tile *>> polygon);
 
        void createAreaTiles(int numberOfLines, int numberOfColumns, double tileSideLength, vector<vector<CommandAreaAnalysis::Tile *>> &tiless);
        bool isValid();
        bool isPointInside(const CscPoint3d *pointToCheck);
        bool isAdjacentTo(Polygon *other);
        bool overlaps(Polygon *other);
 
        CscPoint3d *adjacencyPointWith(Polygon *other);
    };
 
    struct CSC_DLL_IMPORTEXPORT Cell {
        CommandAreaAnalysis::Polygon *polygonCell;
        string name;
        vector<EdgeCell *> adjacentCells;
 
        Cell(Polygon *polygonCell, string name) : polygonCell(polygonCell), name(name) {}
 
        Cell(Cell cell, vector<EdgeCell *> adjacentCells) : adjacentCells(adjacentCells) {
            name = cell.name;
            polygonCell = cell.polygonCell;
        }
 
        struct CSC_DLL_IMPORTEXPORT CellHashPointer {
            std::size_t operator()(const Cell *cell) const {
                return std::hash<std::string>()(cell->name);
            }
        };
 
        struct CSC_DLL_IMPORTEXPORT CellEqualPointer {
            bool operator()(const Cell *lhs, const Cell *rhs) const {
                return lhs->name == rhs->name;
            }
        };
 
        struct CSC_DLL_IMPORTEXPORT CellHash {
            std::size_t operator()(const Cell &cell) const {
                return std::hash<std::string>()(cell.name);
            }
        };
 
        struct CSC_DLL_IMPORTEXPORT CellEqual {
            bool operator()(const Cell &lhs, const Cell &rhs) const {
                return lhs.name == rhs.name;
            }
        };
        void initializeAdjacencyList(vector<Cell *> cellsOfGraph);
    };
    struct CSC_DLL_IMPORTEXPORT EdgeCell {
        Cell *cell;
        double weight;
 
        EdgeCell(Cell *cell, double weight) : cell(cell), weight(weight) {}
    };
 
    struct CSC_DLL_IMPORTEXPORT CellNode {
    public:
        Cell *cell;
        CellNode *parent;
        CellNode(Cell *cell, CellNode *parent) : cell(cell), parent(parent) {}
 
        struct CSC_DLL_IMPORTEXPORT CellNodeHash {
            std::size_t operator()(const CellNode *cellNode) const {
                return std::hash<std::string>()(cellNode->cell->name);
            }
        };
 
        struct CSC_DLL_IMPORTEXPORT CellNodeEqual {
            bool operator()(const CellNode *lhs, const CellNode *rhs) const {
                return lhs->cell->name == rhs->cell->name;
            }
        };
    };
    // Define a struct to represent the adjacency list of a cell
    struct CSC_DLL_IMPORTEXPORT CellAdjacentList {
        Cell cell;
        vector<Cell> adjacencyList;
    };
 
    struct CSC_DLL_IMPORTEXPORT PriorityCell {
        double priority;
        Cell *cell;
 
        PriorityCell(Cell *cell, double priority) : cell(cell), priority(priority) {}
    };
 
    struct CSC_DLL_IMPORTEXPORT CellGraph {
        vector<CommandAreaAnalysis::Polygon *> polygonsOfGraph;
        vector<Cell *> cellsOfGraph;
 
        ~CellGraph() {
            deleteItems(cellsOfGraph);
        }
 
        CellGraph(vector<Polygon *> polygonsOfGraph) : polygonsOfGraph(polygonsOfGraph) {
            int i = 0;
            for (Polygon *polygon : polygonsOfGraph) {
                cellsOfGraph.push_back(new Cell(polygon, to_string(i)));
                i++;
            }
            for (Cell *cell : cellsOfGraph) {
                cell->initializeAdjacencyList(cellsOfGraph);
            }
        }
 
        vector<Cell *> makeTree(unordered_map<Cell, optional<Cell>, Cell::CellHash, Cell::CellEqual> primMap);
 
        unordered_map<Cell, optional<Cell>, Cell::CellHash, Cell::CellEqual> generateSpanningTree(Cell *source);
    };
};
 
COMMAND_REGISTER(CommandAreaAnalysis, ptr<CscEntityReflexion>, vector<const CscPoint3d *>, vector<vector<const CscPoint3d *>> , double, const CscPoint3d *, optional<bool>)
 
}
#endif