Body2DGrid.hpp

Go to the documentation of this file.

#ifndef BODY2DGRID_HPP
#define BODY2DGRID_HPP
 
#include <mecacell/mecacell.h>
#include <mecacell/movable.h>
#include "CellGrid.hpp"
#include "../../../../src/core/BaseBody.hpp"
#define MOVABLE
 
namespace Grid2D {
 
    template<typename cell_t, class plugin_t>
    class Body2DGrid : public MecaCell::Movable, public virtual BaseBody<plugin_t> {
    private:
        double radius = MecaCell::Config::DEFAULT_CELL_RADIUS;
 
        Vec2D position2D = Vec2D(0, 0); 
        int nbNeighbouringLocations = 9; 
        int nbNeighbouringCells = 1; 
        CellGrid<cell_t> *cellGrid = nullptr; 
        MecaCell::Vector3D position;
 
    public:
 
        inline explicit Body2DGrid() = default;
 
        inline explicit Body2DGrid(const MecaCell::Vector3D &pos){
            set2DPosition(Vec2D(pos.x(), pos.y()));
        }
 
        inline int getNbNeighbouringLocations() const { return nbNeighbouringLocations; }
 
        inline void setNbNeighbouringLocations (int n) { nbNeighbouringLocations = n; }
 
        inline int getNbNeighbouringCells() const { return nbNeighbouringCells; }
 
        inline void setNbNeighbouringCells (int n) { nbNeighbouringCells = n; }
 
        inline double getDensity() const { return (double)(nbNeighbouringCells+1) / (double)nbNeighbouringLocations; }
 
        inline double getBoundingBoxRadius() const { return radius; }
 
        inline void setRadius(double _radius) { radius = _radius; }
 
        inline Vec2D get2DPosition() const { return position2D; }
 
        inline MecaCell::Vector3D getPosition() const { return MecaCell::Vector3D(position2D.x(), position2D.y(), 0.); }
 
        inline void set2DPosition(const Vec2D &p) {
            int i = p.x();
            int j = p.y();
 
            int x = position2D.x();
            int y = position2D.y();
 
            position2D = p;
            position = MecaCell::Vector3D(i, j, 0.);
 
            if(this->cellPlugin != nullptr){
                auto cellGrid = getCellGrid();
                int c = 0;
                int nbCellSamePosition = cellGrid->grid[x][y].size();
                while(c < nbCellSamePosition && &(cellGrid->grid[x][y][c]->getBody()) != this) c++;
                if(c < nbCellSamePosition){
                    cellGrid->grid[i][j].push_back(cellGrid->grid[x][y][c]);
                    cellGrid->grid[x][y].erase(cellGrid->grid[x][y].begin() + c);
                }
            }
        }
 
        inline void set2DPosition(int i, int j){ set2DPosition(Vec2D(i, j)); }
 
        inline void setPosition(const MecaCell::Vector3D &p) { set2DPosition(Vec2D((int)p.x(), (int)p.y())); }
 
        inline CellGrid<cell_t> * getCellGrid() { return this->cellPlugin->plugin2DGrid.getCellGrid(); }
 
        Vec2D findLowestDensityPosition(int range) {
 
            std::vector<int> posibilityX;
            std::vector<int> posibilityY;
            int x = position2D.x();
            int y = position2D.y();
            auto cellGrid = getCellGrid();
 
            //find min density in neighbour positions
            int min = std::numeric_limits<int>::max();
            int currentSize;
            for (int i = -range; i <= range; ++i) {
                for (int j = -range; j <= range; ++j) {
                    int xi = x + i;
                    int yj = y + j;
 
                    if (cellGrid->toreX){
                        if(xi < 0) xi = cellGrid->width - xi;
                        if(xi >= cellGrid->width) xi = xi - cellGrid->width;
                    }
                    if(cellGrid->toreY){
                        if(yj < 0) yj = cellGrid->height - yj;
                        if(yj >= cellGrid->height) yj = yj - cellGrid->height;
                    }
 
                    if ((xi >= 0) && (xi < cellGrid->width) && (yj >= 0) && (yj < cellGrid->height)) {
                        currentSize = cellGrid->grid[xi][yj].size();
                        if (currentSize < min) {
                            min = currentSize;
                            posibilityX.clear();
                            posibilityY.clear();
                            posibilityX.push_back(xi);
                            posibilityY.push_back(yj);
                        } else if (currentSize == min) {
                            posibilityX.push_back(xi);
                            posibilityY.push_back(yj);
                        }
                    }
                }
            }
 
            //choose the position
            if (posibilityX.size() > 1) {
                std::uniform_int_distribution<> dis(0, posibilityX.size() - 1);
                int choice = dis(MecaCell::Config::globalRand());
                x = posibilityX[choice];
                y = posibilityY[choice];
            } else {
                x = posibilityX[0];
                y = posibilityY[0];
            }
            return Vec2D(x, y);
        }
    };
}
#endif