von_neumann_grid.h

Go to the documentation of this file.

#ifndef FPMAS_VON_NEUMANN_GRID_H
#define FPMAS_VON_NEUMANN_GRID_H
 
#include "grid_builder.h"
 
namespace fpmas { namespace model {
    using api::model::DiscretePoint;
    using api::model::DiscreteCoordinate;
 
    class ManhattanDistance {
        public:
            DiscreteCoordinate operator()(
                    const DiscretePoint& p1,
                    const DiscretePoint& p2) const {
                return std::abs(p2.x - p1.x) + std::abs(p2.y - p1.y);
            }
    };
 
    template<typename CellType = model::GridCell>
    class VonNeumannGridBuilder : public detail::GridBuilder<CellType> {
        private:
 
            void buildLocalGrid(
                    api::model::SpatialModel<CellType>& model,
                    GridDimensions local_dimensions,
                    typename detail::GridBuilder<CellType>::CellMatrix& cells
                    ) const override;
 
            void linkFrontiers(
                    api::model::SpatialModel<CellType>& model,
                    GridDimensions local_dimensions,
                    typename detail::GridBuilder<CellType>::CellMatrix& local_cells,
                    std::vector<CellType*>& frontier
                    ) const override;
        public:
            using detail::GridBuilder<CellType>::GridBuilder;
    };
 
    template<typename CellType>
    void VonNeumannGridBuilder<CellType>::buildLocalGrid(
            api::model::SpatialModel<CellType>& model,
            GridDimensions local_dimensions,
            typename detail::GridBuilder<CellType>::CellMatrix& cells
            ) const {
        DiscreteCoordinate local_width = local_dimensions.width();
        DiscreteCoordinate local_height = local_dimensions.height();
 
        for(DiscreteCoordinate j = 0; j < local_width; j++) {
            for(DiscreteCoordinate i = 0; i < local_height-1; i++) {
                model.link(cells[i][j], cells[i+1][j], api::model::CELL_SUCCESSOR);
            }
            for(DiscreteCoordinate i = local_height-1; i > 0; i--) {
                model.link(cells[i][j], cells[i-1][j], api::model::CELL_SUCCESSOR);
            }
        }
        for(DiscreteCoordinate i = 0; i < local_height; i++) {
            for(DiscreteCoordinate j = 0; j < local_width-1; j++) {
                model.link(cells[i][j], cells[i][j+1], api::model::CELL_SUCCESSOR);
            }
            for(DiscreteCoordinate j = local_width-1; j > 0; j--) {
                model.link(cells[i][j], cells[i][j-1], api::model::CELL_SUCCESSOR);
            }
        }
    }
    template<typename CellType>
            void VonNeumannGridBuilder<CellType>::linkFrontiers(
                    api::model::SpatialModel<CellType>& model,
                    GridDimensions local_dimensions,
                    typename detail::GridBuilder<CellType>::CellMatrix& local_cells,
                    std::vector<CellType*>& frontier
                    ) const {
                for(auto cell : frontier) {
                    if(cell->location().y == local_dimensions.getExtent().y) {
                        // top
                        if(cell->location().x >= local_dimensions.getOrigin().x
                                && cell->location().x < local_dimensions.getExtent().x) {
                            model.link(
                                    local_cells[local_dimensions.height()-1][cell->location().x - local_dimensions.getOrigin().x],
                                    cell,
                                    SpatialModelLayers::CELL_SUCCESSOR
                                    );
                        }
                    }
                    else if(cell->location().y == local_dimensions.getOrigin().y-1) {
                        // bottom
                        if(cell->location().x >= local_dimensions.getOrigin().x
                                && cell->location().x < local_dimensions.getExtent().x) {
                            model.link(
                                    local_cells[0][cell->location().x - local_dimensions.getOrigin().x],
                                    cell,
                                    SpatialModelLayers::CELL_SUCCESSOR
                                    );
                        }
                    }
                    else if(cell->location().x == local_dimensions.getOrigin().x-1) {
                        // left
                        if(cell->location().y >= local_dimensions.getOrigin().y
                                && cell->location().y < local_dimensions.getExtent().y) {
                            model.link(
                                    local_cells[cell->location().y - local_dimensions.getOrigin().y][0],
                                    cell,
                                    SpatialModelLayers::CELL_SUCCESSOR
                                    );
                        }
                    }
                    else if(cell->location().x == local_dimensions.getExtent().x) {
                        // right
                        if(cell->location().y >= local_dimensions.getOrigin().y
                                && cell->location().y < local_dimensions.getExtent().y) {
                            model.link(
                                    local_cells[cell->location().y - local_dimensions.getOrigin().y][local_dimensions.width()-1],
                                    cell,
                                    SpatialModelLayers::CELL_SUCCESSOR
                                    );
                        }
                    }
                }
            }
 
    template<typename CellType = model::GridCell>
    using VonNeumannGrid = GridConfig<VonNeumannGridBuilder<CellType>, ManhattanDistance, CellType>;
}}
#endif