allow dynamic update of jupedsim shapes #17642

behrisch · behrisch · commit 691e2005d70e · 2026-02-17T13:50:58.000+01:00
diff --git a/src/microsim/MSNet.h b/src/microsim/MSNet.h
@@ -177,7 +177,7 @@ class MSNet : public Parameterised {
     MSNet(MSVehicleControl* vc, MSEventControl* beginOfTimestepEvents,
           MSEventControl* endOfTimestepEvents,
           MSEventControl* insertionEvents,
-          ShapeContainer* shapeCont = 0);
+          ShapeContainer* shapeCont = nullptr);
 
 
     /// @brief Destructor
diff --git a/src/microsim/transportables/MSPModel_JuPedSim.cpp b/src/microsim/transportables/MSPModel_JuPedSim.cpp
@@ -564,13 +564,13 @@ MSPModel_JuPedSim::execute(SUMOTime time) {
     }
 
     // Remove pedestrians that are in a predefined area, at a predefined rate.
-    for (AreaData& area : myAreas) {
-        const std::vector<JPS_Point>& areaBoundary = area.areaBoundary;
+    for (const auto& area : myAreas) {
+        const std::vector<JPS_Point>& areaBoundary = area->areaBoundary;
         JPS_AgentIdIterator agentsInArea = JPS_Simulation_AgentsInPolygon(myJPSSimulation, areaBoundary.data(), areaBoundary.size());
-        if (area.areaType == "vanishing_area") {
-            const SUMOTime period = area.params.count("period") > 0 ? string2time(area.params.at("period")) : 1000;
+        if (area->areaType == "vanishing_area") {
+            const SUMOTime period = area->params.count("period") > 0 ? string2time(area->params.at("period")) : 1000;
             const int nbrPeriodsCoveringTimestep = (int)ceil(TS / STEPS2TIME(period));
-            if (time - area.lastRemovalTime >= nbrPeriodsCoveringTimestep * period) {
+            if (time - area->lastRemovalTime >= nbrPeriodsCoveringTimestep * period) {
                 for (int k = 0; k < nbrPeriodsCoveringTimestep; k++) {
                     const JPS_AgentId agentID = JPS_AgentIdIterator_Next(agentsInArea);
                     if (agentID != 0) {
@@ -584,21 +584,21 @@ MSPModel_JuPedSim::execute(SUMOTime time) {
                             // Code below only works if the removal happens at the last stage.
                             const bool finalStage = person->getNumRemainingStages() == 1;
                             if (finalStage) {
-                                WRITE_MESSAGEF(TL("Person '%' in vanishing area '%' was removed from the simulation."), person->getID(), area.id);
+                                WRITE_MESSAGEF(TL("Person '%' in vanishing area '%' was removed from the simulation."), person->getID(), area->id);
                                 while (!state->getStage()->moveToNextEdge(person, time, 1, nullptr));
                                 registerArrived(agentID);
                                 myPedestrianStates.erase(iterator);
-                                area.lastRemovalTime = time;
+                                area->lastRemovalTime = time;
                             }
                         }
                     }
                 }
             }
         } else {  // areaType == "influencer"
             for (JPS_AgentId agentID = JPS_AgentIdIterator_Next(agentsInArea); agentID != 0; agentID = JPS_AgentIdIterator_Next(agentsInArea)) {
-                if (area.params.count("speed") > 0) {
+                if (area->params.count("speed") > 0) {
                     const JPS_Agent agent = JPS_Simulation_GetAgent(myJPSSimulation, agentID, nullptr);
-                    const double newMaxSpeed = StringUtils::toDouble(area.params.at("speed"));
+                    const double newMaxSpeed = StringUtils::toDouble(area->params.at("speed"));
                     switch (myJPSModel) {
                         case JPS_Model::CollisionFreeSpeed: {
                             JPS_CollisionFreeSpeedModelState modelState = JPS_Agent_GetCollisionFreeSpeedModelState(agent, nullptr);
@@ -1257,19 +1257,7 @@ MSPModel_JuPedSim::initialize(const OptionsCont& oc) {
     }
     // Polygons that define vanishing areas aren't part of the regular JuPedSim geometry.
     for (const auto& polygonWithID : myNetwork->getShapeContainer().getPolygons()) {
-        const SUMOPolygon* const poly = polygonWithID.second;
-        if (poly->getShapeType() == "jupedsim.vanishing_area" || poly->getShapeType() == "jupedsim.influencer") {
-            std::vector<JPS_Point> areaBoundary;
-            for (const Position& p : poly->getShape()) {
-                areaBoundary.push_back({p.x(), p.y()});
-            }
-            // Make sure the shape is not repeating the first point.
-            if (areaBoundary.back().x == areaBoundary.front().x && areaBoundary.back().y == areaBoundary.front().y) {
-                areaBoundary.pop_back();
-            }
-            const std::string type = StringTokenizer(poly->getShapeType(), ".").getVector()[1];
-            myAreas.push_back({poly->getID(), type, areaBoundary, poly->getParametersMap(), 0});
-        }
+        polygonChanged(polygonWithID.second, true, false);
     }
     if (OutputDevice::createDeviceByOption("pedestrian.jupedsim.py")) {
         myPythonScript = &OutputDevice::getDeviceByOption("pedestrian.jupedsim.py");
@@ -1284,6 +1272,36 @@ MSPModel_JuPedSim::initialize(const OptionsCont& oc) {
         crossing.second.first = addWaitingSet(crossing.first, true);
         crossing.second.second = addWaitingSet(crossing.first, false);
     }
+    myNetwork->getShapeContainer().addShapeListener(this);
+}
+
+
+void
+MSPModel_JuPedSim::polygonChanged(const SUMOPolygon* const poly, const bool added, const bool removed) {
+    if (poly->getShapeType() == "jupedsim.vanishing_area" || poly->getShapeType() == "jupedsim.influencer") {
+        SUMOTime lastRemovalTime = 0;
+        if (!added) {
+            for (auto areaIt = myAreas.begin(); areaIt != myAreas.end(); ++areaIt) {
+                if (poly->getID() == (*areaIt)->id) {
+                    lastRemovalTime = (*areaIt)->lastRemovalTime;
+                    myAreas.erase(areaIt);
+                    break;
+                }
+            }
+        }
+        if (!removed) {
+            std::vector<JPS_Point> areaBoundary;
+            for (const Position& p : poly->getShape()) {
+                areaBoundary.push_back({p.x(), p.y()});
+            }
+            // Make sure the shape is not repeating the first point.
+            if (areaBoundary.back().x == areaBoundary.front().x && areaBoundary.back().y == areaBoundary.front().y) {
+                areaBoundary.pop_back();
+            }
+            const std::string type = StringTokenizer(poly->getShapeType(), ".").getVector()[1];
+            myAreas.emplace_back(std::unique_ptr<AreaData>(new AreaData{poly->getID(), type, areaBoundary, poly->getParametersMap(), lastRemovalTime}));
+        }
+    }
 }
 
 
diff --git a/src/microsim/transportables/MSPModel_JuPedSim.h b/src/microsim/transportables/MSPModel_JuPedSim.h
@@ -27,7 +27,8 @@
 #include <map>
 #include <geos_c.h>
 #include <jupedsim/jupedsim.h>
-#include "microsim/MSNet.h"
+#include <utils/shapes/ShapeContainer.h>
+#include <microsim/MSNet.h>
 #include "MSPModel_Interacting.h"
 
 
@@ -45,7 +46,7 @@ class OutputDevice;
  * @brief A pedestrian following model that acts as a proxy for pedestrian models
  * provided by the JuPedSim third-party simulation framework.
  */
-class MSPModel_JuPedSim : public MSPModel_Interacting {
+class MSPModel_JuPedSim : public MSPModel_Interacting, public ShapeListener {
 public:
     MSPModel_JuPedSim(const OptionsCont& oc, MSNet* net);
     ~MSPModel_JuPedSim();
@@ -80,6 +81,9 @@ class MSPModel_JuPedSim : public MSPModel_Interacting {
     };
 
     typedef std::tuple<JPS_StageId, Position, double> WaypointDesc;
+
+    void polygonChanged(const SUMOPolygon* const poly, const bool added, const bool removed) override;
+
 private:
     /**
     * @class PState
@@ -189,14 +193,14 @@ class MSPModel_JuPedSim : public MSPModel_Interacting {
         const std::string id;
         const std::string areaType;
         const std::vector<JPS_Point> areaBoundary;
-        const Parameterised::Map params;
+        const Parameterised::Map& params;
 
         /// @brief The last time a pedestrian was removed in a vanishing area.
         SUMOTime lastRemovalTime;
     };
 
     /// @brief Array of special areas.
-    std::vector<AreaData> myAreas;
+    std::vector<std::unique_ptr<AreaData> > myAreas;
 
     /// @brief Array of stopped trains, used to detect whether to add carriages and ramps to the geometry.
     std::vector<SUMOTrafficObject::NumericalID> myAllStoppedTrainIDs;
diff --git a/src/utils/shapes/ShapeContainer.cpp b/src/utils/shapes/ShapeContainer.cpp
@@ -156,12 +156,24 @@ ShapeContainer::removePolygon(const std::string& id, bool /* useLock */) {
     std::cout << "ShapeContainer: Removing Polygon '" << id << "'" << std::endl;
 #endif
     removePolygonDynamics(id);
+    SUMOPolygon* p = myPolygons.get(id);
+    if (p != nullptr) {
+        for (ShapeListener* listener : myListeners) {
+            listener->polygonChanged(p, false, true);
+        }
+    }
     return myPolygons.remove(id);
 }
 
 
 bool
 ShapeContainer::removePOI(const std::string& id) {
+    PointOfInterest* p = myPOIs.get(id);
+    if (p != nullptr) {
+        for (ShapeListener* listener : myListeners) {
+            listener->poiChanged(p, false, true);
+        }
+    }
     return myPOIs.remove(id);
 }
 
@@ -171,6 +183,9 @@ ShapeContainer::movePOI(const std::string& id, const Position& pos) {
     PointOfInterest* p = myPOIs.get(id);
     if (p != nullptr) {
         static_cast<Position*>(p)->set(pos);
+        for (ShapeListener* listener : myListeners) {
+            listener->poiChanged(p, false, false);
+        }
     }
 }
 
@@ -180,6 +195,9 @@ ShapeContainer::reshapePolygon(const std::string& id, const PositionVector& shap
     SUMOPolygon* p = myPolygons.get(id);
     if (p != nullptr) {
         p->setShape(shape);
+        for (ShapeListener* listener : myListeners) {
+            listener->polygonChanged(p, false, false);
+        }
     }
 }
 
@@ -190,6 +208,9 @@ ShapeContainer::add(SUMOPolygon* poly, bool /* ignorePruning */) {
         delete poly;
         return false;
     }
+    for (ShapeListener* listener : myListeners) {
+        listener->polygonChanged(poly, true, false);
+    }
     return true;
 }
 
@@ -200,6 +221,9 @@ ShapeContainer::add(PointOfInterest* poi, bool /* ignorePruning */) {
         delete poi;
         return false;
     }
+    for (ShapeListener* listener : myListeners) {
+        listener->poiChanged(poi, true, false);
+    }
     return true;
 }
 
diff --git a/src/utils/shapes/ShapeContainer.h b/src/utils/shapes/ShapeContainer.h
@@ -34,6 +34,7 @@
 // class declarations
 // ===========================================================================
 class PolygonDynamics;
+class ShapeListener;
 class SUMOTrafficObject;
 template <class T, class S>
 class ParametrisedWrappingCommand;
@@ -175,6 +176,10 @@ class ShapeContainer {
     /** @brief Remove all dynamics before quick-loading state */
     void clearState();
 
+    void addShapeListener(ShapeListener* listener) {
+        myListeners.push_back(listener);
+    }
+
 protected:
     /// @brief add polygon
     virtual bool add(SUMOPolygon* poly, bool ignorePruning = false);
@@ -221,5 +226,17 @@ class ShapeContainer {
 private:
     /// @brief Command pointers for scheduled polygon update. Maps PolyID->Command
     std::map<const std::string, ParametrisedWrappingCommand<ShapeContainer, PolygonDynamics*>*> myPolygonUpdateCommands;
+    std::vector<ShapeListener*> myListeners;
+
+};
 
+
+/**
+ * @class ShapeListener
+ * @brief Interface for objects which want to be notified about shape updates
+ */
+class ShapeListener {
+public:
+    virtual void polygonChanged(const SUMOPolygon* const poly, const bool added, const bool removed) {}
+    virtual void poiChanged(const PointOfInterest* const poi, const bool added, const bool removed) {}
 };

Original file line number	Diff line number	Diff line change
`@@ -156,12 +156,24 @@ ShapeContainer::removePolygon(const std::string& id, bool /* useLock */) {`
`156`	`156`	`std::cout << "ShapeContainer: Removing Polygon '" << id << "'" << std::endl;`
`157`	`157`	`#endif`
`158`	`158`	`removePolygonDynamics(id);`
	`159`	`+ SUMOPolygon* p = myPolygons.get(id);`
	`160`	`+ if (p != nullptr) {`
	`161`	`+ for (ShapeListener* listener : myListeners) {`
	`162`	`+ listener->polygonChanged(p, false, true);`
	`163`	`+ }`
	`164`	`+ }`
`159`	`165`	`return myPolygons.remove(id);`
`160`	`166`	`}`
`161`	`167`
`162`	`168`
`163`	`169`	`bool`
`164`	`170`	`ShapeContainer::removePOI(const std::string& id) {`
	`171`	`+ PointOfInterest* p = myPOIs.get(id);`
	`172`	`+ if (p != nullptr) {`
	`173`	`+ for (ShapeListener* listener : myListeners) {`
	`174`	`+ listener->poiChanged(p, false, true);`
	`175`	`+ }`
	`176`	`+ }`
`165`	`177`	`return myPOIs.remove(id);`
`166`	`178`	`}`
`167`	`179`
`@@ -171,6 +183,9 @@ ShapeContainer::movePOI(const std::string& id, const Position& pos) {`
`171`	`183`	`PointOfInterest* p = myPOIs.get(id);`
`172`	`184`	`if (p != nullptr) {`
`173`	`185`	`static_cast<Position*>(p)->set(pos);`
	`186`	`+ for (ShapeListener* listener : myListeners) {`
	`187`	`+ listener->poiChanged(p, false, false);`
	`188`	`+ }`
`174`	`189`	`}`
`175`	`190`	`}`
`176`	`191`
`@@ -180,6 +195,9 @@ ShapeContainer::reshapePolygon(const std::string& id, const PositionVector& shap`
`180`	`195`	`SUMOPolygon* p = myPolygons.get(id);`
`181`	`196`	`if (p != nullptr) {`
`182`	`197`	`p->setShape(shape);`
	`198`	`+ for (ShapeListener* listener : myListeners) {`
	`199`	`+ listener->polygonChanged(p, false, false);`
	`200`	`+ }`
`183`	`201`	`}`
`184`	`202`	`}`
`185`	`203`
`@@ -190,6 +208,9 @@ ShapeContainer::add(SUMOPolygon* poly, bool /* ignorePruning */) {`
`190`	`208`	`delete poly;`
`191`	`209`	`return false;`
`192`	`210`	`}`
	`211`	`+ for (ShapeListener* listener : myListeners) {`
	`212`	`+ listener->polygonChanged(poly, true, false);`
	`213`	`+ }`
`193`	`214`	`return true;`
`194`	`215`	`}`
`195`	`216`
`@@ -200,6 +221,9 @@ ShapeContainer::add(PointOfInterest* poi, bool /* ignorePruning */) {`
`200`	`221`	`delete poi;`
`201`	`222`	`return false;`
`202`	`223`	`}`
	`224`	`+ for (ShapeListener* listener : myListeners) {`
	`225`	`+ listener->poiChanged(poi, true, false);`
	`226`	`+ }`
`203`	`227`	`return true;`
`204`	`228`	`}`
`205`	`229`