WaitingAreas are now considered in FF

IO/GeoFileParser.cpp

@@ -476,8 +476,23 @@ bool GeoFileParser::LoadRoutingInfo(Building* building)
                     return false;
                }
 
+
+//               for (auto& room : building->GetAllRooms()){
+//                    for (auto& subroomMap : room.second->GetAllSubRooms()){
+//                         std::cout << "check if wa " << wa->GetId() << " is in subroom " << subroomMap.second->GetSubRoomID() << std::endl;
+//                         std::cout << "wa centroid " << wa->GetCentroid().toString()  << std::endl;
+//
+//                         if (subroomMap.second->IsInSubRoom(wa->GetCentroid()) || subroomMap.second->GetSubRoomID() == 3){
+//                              subroomMap.second->AddGoalID(wa->GetId());
+//                         }
+//                    }
+//               }
+
                building->AddGoal(wa);
                _configuration->GetRoutingEngine()->AddFinalDestinationID(wa->GetId());
+               for (auto &itrGoal : building->GetAllGoals()) {
+                    std::cout << "Goal ID: " << itrGoal.second->GetId() << std::endl;
+               }
 
                std::cout << waitingArea->toString() << std::endl;
 

IO/IniFileParser.cpp

@@ -1179,21 +1179,21 @@ bool IniFileParser::ParseRoutingStrategies(TiXmlNode* routingNode, TiXmlNode* ag
                exit(EXIT_FAILURE);
      #endif
           }
-                    else if ((strategy == "AI_trips") &&
-                   (std::find(usedRouter.begin(), usedRouter.end(), id) != usedRouter.end()) ) {
-     #ifdef AIROUTER
-               Router *r = new AIRouterTrips(id, ROUTING_AI_TRIPS);
-               _config->GetRoutingEngine()->AddRouter(r);
-
-               Log->Write("\nINFO: \tUsing AIRouter Trips");
-               ///Parsing additional options
-               if (!ParseAIOpts(e))
-                    return false;
-     #else
-               std::cerr << "\nCan not use AI Router. Rerun cmake with option  -DAIROUTER=true and recompile.\n";
-               exit(EXIT_FAILURE);
-     #endif
-          }
+//                    else if ((strategy == "AI_trips") &&
+//                   (std::find(usedRouter.begin(), usedRouter.end(), id) != usedRouter.end()) ) {
+//     #ifdef AIROUTER
+//               Router *r = new AIRouterTrips(id, ROUTING_AI_TRIPS);
+//               _config->GetRoutingEngine()->AddRouter(r);
+//
+//               Log->Write("\nINFO: \tUsing AIRouter Trips");
+//               ///Parsing additional options
+//               if (!ParseAIOpts(e))
+//                    return false;
+//     #else
+//               std::cerr << "\nCan not use AI Router. Rerun cmake with option  -DAIROUTER=true and recompile.\n";
+//               exit(EXIT_FAILURE);
+//     #endif
+//          }
 
           else if ((strategy == "ff_global_shortest_trips") &&
                    (std::find(usedRouter.begin(), usedRouter.end(), id) != usedRouter.end()) ) {

events/EventManager.cpp

@@ -38,6 +38,7 @@
 #include "../geometry/SubRoom.h"
 #include "../tinyxml/tinyxml.h"
 #include "../routing/global_shortest/GlobalRouter.h"
+#include "../routing/global_shortest_trips/GlobalRouterTrips.h"
 #include "../routing/quickest/QuickestPathRouter.h"
 #include "../routing/smoke_router/SmokeRouter.h"
 #include "../routing/ff_router/ffRouter.h"
@@ -659,11 +660,11 @@ Router * EventManager::CreateRouter(const RoutingStrategy& strategy)
      switch(strategy)
      {
           case ROUTING_LOCAL_SHORTEST:
-               rout = new GlobalRouter(ROUTING_LOCAL_SHORTEST, ROUTING_LOCAL_SHORTEST);
+               rout = new GlobalRouterTrips(ROUTING_LOCAL_SHORTEST, ROUTING_LOCAL_SHORTEST);
                break;
 
           case ROUTING_GLOBAL_SHORTEST:
-               rout = new GlobalRouter(ROUTING_GLOBAL_SHORTEST, ROUTING_GLOBAL_SHORTEST);
+               rout = new GlobalRouterTrips(ROUTING_GLOBAL_SHORTEST, ROUTING_GLOBAL_SHORTEST);
                break;
 
           case ROUTING_QUICKEST:

events/EventManager.h

@@ -31,7 +31,7 @@
 
 class Building;
 class Router;
-class GlobalRouter;
+class GlobalRouterTrips;
 class QuickestPathRouter;
 class RoutingEngine;
 class Event;

general/Macros.h

@@ -209,6 +209,22 @@ enum MagicNumbers{
      TARGET_REGION
 };
 
+enum SPEEDFIELD {        //this enum is used as index in _speedFieldSelector
+    INITIAL_SPEED=0,    //homogen speed in walkable area, nealy zero in walls
+    REDU_WALL_SPEED=1,   //reduced wall speed
+    PED_SPEED=2         //standing agents reduce speed, so that jams will be considered in ff
+};
+
+enum TARGETMODE {
+    LINESEGMENT=0,
+    CENTERPOINT
+};
+
+enum USERMODE {
+    DISTANCE_MEASUREMENTS_ONLY,
+    DISTANCE_AND_DIRECTIONS_USED
+};
+
 constexpr double magicnum(int i) {
      return (i == UNKNOWN_DISTANCE) ? -3.0 : (i == UNKNOWN_COST) ? -2.0 : (i == WALL_ON_COSTARRAY) ? -7.0 : (i == TARGET_REGION) ? 0.0 : J_NAN;
 //     switch (i) {

geometry/Building.cpp

@@ -846,6 +846,8 @@ bool Building::AddGoal(Goal* goal)
           exit(EXIT_FAILURE);
      }
      _goals[goal->GetId()] = goal;
+
+
      return true;
 }
 

geometry/Building.h

@@ -59,6 +59,8 @@ class PedDistributor;
 
 class Configuration;
 
+class WaitingArea;
+
 class Building {
 private:
      Configuration* _configuration;
@@ -72,6 +74,7 @@ private:
      std::map<int, Transition*> _transitions;
      std::map<int, Hline*> _hLines;
      std::map<int, Goal*> _goals;
+     std::map<int, std::vector<WaitingArea*>> _sr2wa;
 
      /// pedestrians pathway
      bool _savePathway;

geometry/SubRoom.cpp

@@ -33,6 +33,7 @@
 #include "SubRoom.h"
 #include "Transition.h"
 #include "Hline.h"
+#include "WaitingArea.h"
 
 
 #ifdef _SIMULATOR
@@ -1491,6 +1492,13 @@ std::vector<Point> SubRoom::StartLLCorner(const std::vector<Point> &polygon)
 
 }
 
+std::vector<WaitingArea*> SubRoom::GetAllWaitingAreas()
+{
+
+
+     return vector<WaitingArea*>();
+}
+
 /// Escalator
 
 Escalator::Escalator(): Stair() {

geometry/SubRoom.h

@@ -56,6 +56,7 @@ class Crossing;
 class Line;
 class Point;
 class Wall;
+class WaitingArea;
 
 #ifdef _SIMULATOR
 class Pedestrian;
@@ -101,6 +102,8 @@ protected:
 
      polygon_type _boostPoly;
      std::vector<polygon_type> _boostPolyObstacles;
+     std::vector<polygon_type> _boostPolyWall;
+
      std::vector<double> _poly_help_constatnt; //for the function IsInsidePolygon, a.brkic
      std::vector<double> _poly_help_multiple; //for the function IsInsidePolygon, a.brkic
      std::vector<Obstacle*> _obstacles;
@@ -392,6 +395,8 @@ public:
      ///check whether the pedestrians is still in the subroom
      virtual bool IsInSubRoom(const Point& ped) const = 0;
 
+     std::vector<WaitingArea*> GetAllWaitingAreas();
+
 #ifdef _SIMULATOR
 
      virtual bool IsInSubRoom(Pedestrian* ped) const;

geometry/WaitingArea.cpp

@@ -99,3 +99,7 @@ void WaitingArea::setWaitingTime(double waitingTime)
      WaitingArea::waitingTime = waitingTime;
 }
 
+std::vector<Line> WaitingArea::getAllLines()
+{
+
+}

geometry/WaitingArea.h

@@ -6,9 +6,12 @@
 #define _WAITINGAREA_H
 
 #include "Goal.h"
+#include "Line.h"
+
 #include <vector>
 #include <map>
 #include <stdio.h>
+
 class WaitingArea : public Goal{
 
 protected:
@@ -61,6 +64,8 @@ public:
 
     void setWaitingTime(double waitingTime);
 
+    std::vector<Line> getAllLines();
+
 private:
     void updateProbabilities();
     bool checkProbabilities();

routing/ff_router/UnivFFviaFM.cpp

@@ -919,9 +919,9 @@ void UnivFFviaFM::drawLinesOnWall(Line& line, T* const target, const T value) {
 } //drawLinesOnWall
 
 void UnivFFviaFM::calcFF(double* costOutput, Point* directionOutput, const double *const speed) {
-     //CompareCost comp = CompareCost(costOutput);
-     std::priority_queue<long int, std::vector<long int>, CompareCost> trialfield(costOutput); //pass the argument for the constr of CompareCost
-     //std::priority_queue<long int, std::vector<long int>, CompareCost> trialfield2(comp);      //pass the CompareCost object directly
+     //CompareCostTrips comp = CompareCostTrips(costOutput);
+     std::priority_queue<long int, std::vector<long int>, CompareCostTrips> trialfield(costOutput); //pass the argument for the constr of CompareCostTrips
+     //std::priority_queue<long int, std::vector<long int>, CompareCostTrips> trialfield2(comp);      //pass the CompareCostTrips object directly
 
      directNeighbor local_neighbor = _grid->getNeighbors(0);
      long int aux = 0;
@@ -1111,9 +1111,9 @@ void UnivFFviaFM::calcCost(const long int key, double* cost, Point* dir, const d
 }
 
 void UnivFFviaFM::calcDF(double* costOutput, Point* directionOutput, const double *const speed) {
-     //CompareCost comp = CompareCost(costOutput);
-     std::priority_queue<long int, std::vector<long int>, CompareCost> trialfield(costOutput); //pass the argument for the constr of CompareCost
-     //std::priority_queue<long int, std::vector<long int>, CompareCost> trialfield2(comp);      //pass the CompareCost object directly
+     //CompareCostTrips comp = CompareCostTrips(costOutput);
+     std::priority_queue<long int, std::vector<long int>, CompareCostTrips> trialfield(costOutput); //pass the argument for the constr of CompareCostTrips
+     //std::priority_queue<long int, std::vector<long int>, CompareCostTrips> trialfield2(comp);      //pass the CompareCostTrips object directly
 
      directNeighbor local_neighbor = _grid->getNeighbors(0);
      long int aux = 0;

routing/ff_router/UnivFFviaFM.h

@@ -51,25 +51,25 @@ class Point;
 class RectGrid;
 class Line;
 
-enum SPEEDFIELD {        //this enum is used as index in _speedFieldSelector
-     INITIAL_SPEED=0,    //homogen speed in walkable area, nealy zero in walls
-     REDU_WALL_SPEED=1,   //reduced wall speed
-     PED_SPEED=2         //standing agents reduce speed, so that jams will be considered in ff
-};
-
-enum TARGETMODE {
-     LINESEGMENT=0,
-     CENTERPOINT
-};
-
-enum USERMODE {
-     DISTANCE_MEASUREMENTS_ONLY,
-     DISTANCE_AND_DIRECTIONS_USED
-};
+//enum SPEEDFIELD {        //this enum is used as index in _speedFieldSelector
+//     INITIAL_SPEED=0,    //homogen speed in walkable area, nealy zero in walls
+//     REDU_WALL_SPEED=1,   //reduced wall speed
+//     PED_SPEED=2         //standing agents reduce speed, so that jams will be considered in ff
+//};
+//
+//enum TARGETMODE {
+//     LINESEGMENT=0,
+//     CENTERPOINT
+//};
+//
+//enum USERMODE {
+//     DISTANCE_MEASUREMENTS_ONLY,
+//     DISTANCE_AND_DIRECTIONS_USED
+//};
 
-class CompareCost {      //this class is used in std::priority_queue in UnivFFviaFM::calcFF
+class CompareCostTrips {      //this class is used in std::priority_queue in UnivFFviaFM::calcFF
 public:
-     CompareCost(double* costarray) : _costarray(costarray) {}
+     CompareCostTrips(double* costarray) : _costarray(costarray) {}
      bool operator() (const int a, const int b) const {
           return _costarray[a] > _costarray[b];
      }

routing/ff_router_trips/FFKit.cpp

-//
-// Created by arne on 3/29/17.
-//
-/**
- * \file        FFKit.h
- * \date        Mar 29, 2017
- * \version
- * \copyright   <2016-2022> Forschungszentrum Jülich GmbH. All rights reserved.
- *
- * \section License
- * This file is part of JuPedSim.
- *
- * JuPedSim is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * any later version.
- *
- * JuPedSim is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
- *
- * \section Description
- * The Floorfield Kit is the rework of the prototype FloorfieldViaFM - class.
- * It will restructur the former version to avoid several downsides (diamond
- * inheritance, line/centerpoint version (DRY), overdoing the precalc, ...)
- * We try to build it in a cleaner, easier version.
- *
- * A floorfield will be calculated and stored. The user can access distances(cost)
- * values as well as the gradient of that.
- *
- * Cost Values are calculated via the fastmarching algorithm. Other algorithms might
- * follow, if they provide better abilities to work in paralell.
- *
- * The new grid-code/subroom version should be reused for all floorfields, that work
- * on the same part of the geometry (room/subroom e.g. floor/room)
- *
- **/
-
-#include "FFKit.h"

routing/ff_router_trips/FFKit.h

-//
-// Created by arne on 3/29/17.
-//
-/**
- * \file        ffRouter.h
- * \date        Feb 19, 2016
- * \version     v0.8
- * \copyright   <2016-2022> Forschungszentrum Jülich GmbH. All rights reserved.
- *
- * \section License
- * This file is part of JuPedSim.
- *
- * JuPedSim is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * any later version.
- *
- * JuPedSim is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
- *
- * \section Description
- *
- * The Floorfield Kit is the rework of the prototype FloorfieldViaFM - class.
- * It will restructur the former version to avoid several downsides (diamond
- * inheritance, line/centerpoint version (DRY), overdoing the precalc, ...)
- * We try to build it in a cleaner, easier version.
- *
- * A floorfield will be calculated and stored. The user can access distances(cost)
- * values as well as the gradient of that.
- *
- * Cost Values are calculated via the fastmarching algorithm. Other algorithms might
- * follow, if they provide better abilities to work in paralell.
- *
- * The new grid-code/subroom version should be reused for all floorfields, that work
- * on the same part of the geometry (room/subroom e.g. floor/room)
- *
- * old ffrouter description:
- * This router is an update of the former Router.{cpp, h} - Global-, Quickest
- * Router System. In the __former__ version, a graph was created with doors and
- * hlines as nodes and the distances of (doors, hlines), connected with a line-
- * of-sight, was used as edge-costs. If there was no line-of-sight, there was no
- * connecting edge. On the resulting graph, the Floyd-Warshall algorithm was
- * used to find any paths. In the "quickest-___" variants, the edge cost was not
- * determined by the distance, but by the distance multiplied by a speed-
- * estimate, to find the path with minimum travel times. This whole construct
- * worked pretty well, but dependend on hlines to create paths with line-of-
- * sights to the next target (hline/door).
- *
- * In the ffRouter, we want to overcome hlines by using floor fields to
- * determine the distances. A line of sight is not required any more. We hope to
- * reduce the graph complexity and the preparation-needs for new geometries.
- *
- * To find a counterpart for the "quickest-____" router, we can either use
- * __special__ floor fields, that respect the travel time in the input-speed map,
- * or take the distance-floor field and multiply it by a speed-estimate (analog
- * to the former construct.
- *
- * We will derive from the <Router> class to fit the interface.
- *
- * Questions to solve: how to deal with goalID == doorID problem in matrix
- *
- * Restrictions/Requirements: Floorfields are not really 3D supporting:
- *
- * A room may not consist of subrooms which overlap in their projection (onto
- * x-y-plane). So subrooms, that are positioned on top of others (in stairways
- * for example), must be separated into different rooms.
- *
- * floorfields do not consider z-coordinates. Distances of two grid points are
- * functions of (x, y) and not (x, y, z). Any slope will be neglected.
- *
- **/
-
-#ifndef JPSCORE_FFKIT_H
-#define JPSCORE_FFKIT_H
-
-#include <vector>
-#include <unordered_set>
-#include <cmath>
-#include <functional>
-#include "mesh/RectGrid.h"
-#include "../../geometry/Wall.h"
-#include "../../geometry/Point.h"
-#include "../../geometry/Building.h"
-#include "../../geometry/SubRoom.h" //check: should Room.h include SubRoom.h??
-#include "./mesh/Trial.h"
-#include "../../pedestrian/Pedestrian.h"
-
-//class Building;
-//class Pedestrian;
-class OutputHandler;
-
-//log output
-extern OutputHandler* Log;
-
-
-
-
-#endif //JPSCORE_FFKIT_H

routing/ff_router_trips/FloorfieldViaFM.h

-/**
- * \file        FloorfieldViaFM.h
- * \date        Mar 05, 2015
- * \version     N/A (v0.6)
- * \copyright   <2009-2014> Forschungszentrum Jülich GmbH. All rights reserved.
- *
- * \section License
- * This file is part of JuPedSim.
- *
- * JuPedSim is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * any later version.
- *
- * JuPedSim is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
- *
- * \section Description
- * Implementation of classes for ...
- *
- *
- **/
-
- //remark:
- //refac the code to use enums instead of integer values where integer values code sth
- //was considered, but enum classes do not implicitly cast to int
- //rather use makros/masks like in plain C? or just makros (defines)?
- //this would make it easier to read
-
-#ifndef FLOORFIELDVIAFM_H
-#define FLOORFIELDVIAFM_H
-
-#include <vector>
-#include <unordered_set>
-#include <cmath>
-#include <functional>
-#include "mesh/RectGrid.h"
-#include "../../geometry/Wall.h"
-#include "../../geometry/Point.h"
-#include "../../geometry/Building.h"
-#include "../../geometry/SubRoom.h" //check: should Room.h include SubRoom.h??
-#include "./mesh/Trial.h"
-#include "../../pedestrian/Pedestrian.h"
-
-//maybe put following in macros.h
-#define LOWSPEED 0.001
-
-class TrialP
-{
-public:
-     long int key;
-     int* flag;
-     double* cost;
-     double* speed;
-     Point* neggrad;
-
-     TrialP() {
-          key = 0;
-          flag = nullptr;
-          cost = nullptr;
-          speed = nullptr;
-          neggrad = nullptr;
-     }
-
-     TrialP(long int keyArg, double* t, double* f, int* flagArg, Point* neggradArg) {
-          key = keyArg;
-          cost = t;
-          speed = f;
-          flag = flagArg;
-          neggrad = neggradArg;
-     }
-
-     ~TrialP(){}
-
-     bool operator <(const TrialP& rhs) const
-     {
-          return this->cost[this->key] < rhs.cost[rhs.key];
-     }
-
-     bool operator >(const TrialP& rhs) const
-     {
-          return this->cost[this->key] > rhs.cost[rhs.key];
-     }
-
-     bool operator ==(const TrialP& rhs) const
-     {
-          return this->cost[this->key] == rhs.cost[rhs.key];
-     }
-};
-
-class FloorfieldViaFM
-{
-public:
-     FloorfieldViaFM();
-     FloorfieldViaFM(const std::string&);
-     FloorfieldViaFM(const Building* const buildingArg, const double hxArg, const double hyArg,
-                     const double wallAvoidDistance, const bool useDistancefield, const bool onlyRoomsWithExits);
-     //FloorfieldViaFM(const FloorfieldViaFM* const refFM);
-     virtual ~FloorfieldViaFM();
-     FloorfieldViaFM(const FloorfieldViaFM& other); //will not make a copy; only takes geometry info
-     //FloorfieldViaFM& operator=(const FloorfieldViaFM& other);
-
-     //void getDirectionAt(const Point& position, Point& direction);                                   //obsolete
-     //void getDirectionToDestination (const int destID, const Point& position, Point& direction);     //obsolete
-     void getDirectionToUID(int destID, const long int key, Point& direction); // shall not be used any more, therefore not virtual
-     virtual void getDirectionToUID(int destID, const long int key, Point& direction, int mode);
-     //void getDirectionToUIDParallel(int destID, const long int key, Point& direction);
-     virtual void getDirectionToDestination (Pedestrian* ped, Point& direction);
-     //void getDirectionToFinalDestination(Pedestrian* ped, Point& direction); //this is router buissness! problem in multi-storage buildings
-
-     void createMapEntryInLineToGoalID(const int goalID);
-
-     double getCostToDestination(const int destID, const Point& position);
-     double getCostToDestination(const int destID, const Point& position, int mode);
-     //double getCostToDestinationParallel(const int destID, const Point& position);
-
-     void getDir2WallAt(const Point& position, Point& direction);
-     double getDistance2WallAt(const Point& position);
-
-     int getSubroomUIDAt(const Point& position);
-
-     void parseBuilding(const Building* const buildingArg, const double stepSizeX, const double stepSizeY);
-     void parseBuildingForExits(const Building* const buildingArg, const double stepSizeX, const double stepSizeY);
-     void prepareForDistanceFieldCalculation(const bool withExits);
-     template <typename T>
-     void drawLinesOnGrid(std::vector<Line>& wallArg, T* const target, const T value);
-     void setSpeed(bool useDistance2WallArg);
-     void setSpeedThruPeds(Pedestrian* const* pedsArg, int nPeds, int modechoice, double radius);
-     void deleteAllFFs();
-     void clearAndPrepareForFloorfieldReCalc(double* costarray);
-     void setNewGoalAfterTheClear(double* costarray, std::vector<Line>& GoalWallArg);
-     void calculateFloorfield(std::vector<Line>& wallArg, double* costarray, Point* neggradarray);   //make private
-     void calculateFloorfield(std::vector<Line>& wallArg, double* costarray, Point* neggradarray, double* speedarray);
-     void calculateDistanceField(const double thresholdArg);             //make private
-
-     void checkNeighborsAndAddToNarrowband(std::priority_queue<TrialP, std::vector<TrialP>, std::greater<TrialP> >& trialfield, TrialP key,
-                                           std::function<void (TrialP)> calc);
-
-     void calcDist2Wall(TrialP);
-     void calcFloorfield(TrialP);
-     //void (*checkNeighborsAndCalc)(const long int key);
-
-     inline double onesidedCalc(double xy, double hDivF);
-     inline double twosidedCalc(double x, double y, double hDivF);
-
-     void testoutput(const char*, const char*, const double*);
-     void writeFF(const std::string&, std::vector<int> targetID);
-     void writeGoalFF(const std::string&, std::vector<int> targetID);
-
-     virtual SubRoom* isInside(const long int key);
-     SubRoom* GetSubroom(Pedestrian* p);
-
-     std::map<int, int> getGoalToLineUIDmap() const
-     {
-          return _goalToLineUIDmap;
-     }
-
-     std::map<int, int> getGoalToLineUIDmap2() const
-     {
-          return _goalToLineUIDmap2;
-     }
-
-     std::map<int, int> getGoalToLineUIDmap3() const
-     {
-          return _goalToLineUIDmap3;
-     }
-
-     RectGrid* getGrid() const
-     {
-          return _grid;
-     }
-
-#ifdef TESTING
-     void setGrid(RectGrid* gridArg) {_grid = gridArg;}
-#endif //TESTING
-
-protected:
-     RectGrid* _grid = nullptr;
-     std::vector<Line> _wall;
-     std::vector<Line> _exitsFromScope;
-     unsigned int _numOfExits;
-
-     const Building* _building;
-
-     //GridPoint Data in independant arrays (shared primary key)
-     // changed to threadsafe creation when needed: int* flag;
-     int* _gcode = nullptr;                 //gridcode (see Macros.h)
-     SubRoom* * _subrooms = nullptr; // this is an array (first asterisk) of pointers (second asterisk)
-     double* _dist2Wall = nullptr;
-     double* _speedInitial = nullptr;
-     double* _modifiedspeed = nullptr;
-     double* _densityspeed = nullptr;
-     double* _cost = nullptr;
-     //long int* secKey;  //secondary key to address ... not used yet
-     Point* _neggrad = nullptr; //gradients
-     Point* _dirToWall = nullptr;
-     // changed to threadsafe creation when needed: Trial* trialfield;
-
-     std::map<int, double*> _goalcostmap;
-     std::map<int, int>     _goalToLineUIDmap; //key is the goalID and value is the UID of closest transition -> it maps goal to LineUID
-     std::map<int, int>     _goalToLineUIDmap2;
-     std::map<int, int>     _goalToLineUIDmap3;
-     std::map<int, Point*>  _goalneggradmap;
-     std::map<int, double*> _costmap;
-     std::map<int, Point*>  _neggradmap;
-     // use an unordered_set for faster access (it is accessed within a critical region)
-     std::unordered_set<int>  _floorfieldsBeingCalculated;
-     bool maps_deleted = false; // @todo f.mack remove
-
-     double _threshold;
-     bool _useDistanceToWall;
-};
-
-// very similar to FloorfieldViaFM, but the calculation of floorfields starts at the center of the door only, not on the whole line
-// this happens in order to avoid "door hopping" (for a pedestrian, it is shorter to go to a nearby door and skip half the door width)
-class CentrePointFFViaFM : public virtual FloorfieldViaFM {
-public:
-     virtual void getDirectionToUID(int destID, const long int key, Point& direction, int mode);
-};
-
-#endif // FLOORFIELDVIAFM_H

routing/ff_router_trips/LocalFloorfieldViaFM.h

-/**
- * \file        LocalFloorfieldViaFM.h
- * \date        Feb 1, 2016
- * \version     v0.8 +
- * \copyright   <2009-2015> Forschungszentrum Jülich GmbH. All rights reserved.
- *
- * \section License
- * This file is part of JuPedSim.
- *
- * JuPedSim is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * any later version.
- *
- * JuPedSim is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with JuPedSim. If not, see <http://www.gnu.org/licenses/>.
- *
- * \section Description
- * The local FloorfieldViaFM is derived from the FloorfieldViaFM class. It will
- * create Floorfields in a room (room consisting of one or more subrooms) for
- * each exit. It is to be used in conjunction with a router, yielding intermediate
- * goals which are a door in the same room. It uses all the calculations and the
- * working on grid form the motherclass, yet it has a different constructor.
- **/
-
-
-#ifndef JPSCORE_LOCALFLOORFIELDVIAFM_H
-#define JPSCORE_LOCALFLOORFIELDVIAFM_H
-
-//#include <vector>
-#include <string>
-#include "FloorfieldViaFM.h"
-