Eclipse SUMO - Simulation of Urban MObility
libsumo/Polygon.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2017-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
18 // C++ TraCI client API implementation
19 /****************************************************************************/
20 #include <microsim/MSNet.h>
25 #include <libsumo/TraCIConstants.h>
30 
31 #include "Polygon.h"
32 #include "Helper.h"
33 
34 
35 namespace libsumo {
36 // ===========================================================================
37 // static member initializations
38 // ===========================================================================
39 SubscriptionResults Polygon::mySubscriptionResults;
40 ContextSubscriptionResults Polygon::myContextSubscriptionResults;
41 NamedRTree* Polygon::myTree(nullptr);
42 
43 
44 // ===========================================================================
45 // static member definitions
46 // ===========================================================================
47 std::vector<std::string>
48 Polygon::getIDList() {
49  std::vector<std::string> ids;
51  shapeCont.getPolygons().insertIDs(ids);
52  return ids;
53 }
54 
55 
56 int
57 Polygon::getIDCount() {
58  return (int)getIDList().size();
59 }
60 
61 
62 std::string
63 Polygon::getType(const std::string& polygonID) {
64  return getPolygon(polygonID)->getShapeType();
65 }
66 
67 
68 TraCIPositionVector
69 Polygon::getShape(const std::string& polygonID) {
70  SUMOPolygon* p = getPolygon(polygonID);
72 }
73 
74 
75 bool
76 Polygon::getFilled(const std::string& polygonID) {
77  return getPolygon(polygonID)->getFill();
78 }
79 
80 double
81 Polygon::getLineWidth(const std::string& polygonID) {
82  return getPolygon(polygonID)->getLineWidth();
83 }
84 
85 TraCIColor
86 Polygon::getColor(const std::string& polygonID) {
87  SUMOPolygon* p = getPolygon(polygonID);
89 }
90 
91 
92 std::string
93 Polygon::getParameter(const std::string& polygonID, const std::string& key) {
94  return getPolygon(polygonID)->getParameter(key, "");
95 }
96 
97 
99 
100 
101 void
102 Polygon::setType(const std::string& polygonID, const std::string& setType) {
103  SUMOPolygon* p = getPolygon(polygonID);
104  p->setShapeType(setType);
105 }
106 
107 
108 void
109 Polygon::setShape(const std::string& polygonID, const TraCIPositionVector& shape) {
110  PositionVector positionVector = Helper::makePositionVector(shape);
111  getPolygon(polygonID); // just to check whether it exists
113  shapeCont.reshapePolygon(polygonID, positionVector);
114 }
115 
116 
117 void
118 Polygon::setColor(const std::string& polygonID, const TraCIColor& c) {
119  getPolygon(polygonID)->setShapeColor(Helper::makeRGBColor(c));
120 }
121 
122 
123 void
124 Polygon::add(const std::string& polygonID, const TraCIPositionVector& shape, const TraCIColor& color, bool fill, const std::string& polygonType, int layer, double lineWidth) {
127  RGBColor col = Helper::makeRGBColor(color);
128  if (!shapeCont.addPolygon(polygonID, polygonType, col, (double)layer, Shape::DEFAULT_ANGLE, Shape::DEFAULT_IMG_FILE, Shape::DEFAULT_RELATIVEPATH, pShape, false, fill, lineWidth)) {
129  throw TraCIException("Could not add polygon '" + polygonID + "'");
130  }
131  if (myTree != nullptr) {
132  SUMOPolygon* p = shapeCont.getPolygons().get(polygonID);
133  Boundary b = p->getShape().getBoxBoundary();
134  const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
135  const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
136  myTree->Insert(cmin, cmax, p);
137  }
138 }
139 
140 
141 void
142 Polygon::addHighlightPolygon(const std::string& objectID, const int type, const std::string& polygonID, const TraCIPositionVector& shape, const TraCIColor& color, bool fill, const std::string& polygonType, int layer, double lineWidth) {
143  add(polygonID, shape, color, fill, polygonType, layer, lineWidth);
144  MSNet::getInstance()->getShapeContainer().registerHighlight(objectID, type, polygonID);
145 }
146 
147 
148 void
149 Polygon::addDynamics(const std::string& polygonID, const std::string& trackedObjectID, const std::vector<double>& timeSpan, const std::vector<double>& alphaSpan, bool looped, bool rotate) {
150  if (timeSpan.empty()) {
151  if (trackedObjectID == "") {
152  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': dynamics underspecified (either a tracked object ID or a time span have to be provided).");
153  }
154  if (looped) {
155  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': looped==true requires time line of positive length.");
156  }
157  }
158  if (timeSpan.size() == 1) {
159  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': time span cannot have length one.");
160  } else if (timeSpan.size() > 0 && timeSpan[0] != 0.0) {
161  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': first element of time span must be zero.");
162  }
163  if (timeSpan.size() != alphaSpan.size() && alphaSpan.size() != 0) {
164  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': alpha span must have length zero or equal to time span length.");
165  }
166  if (timeSpan.size() >= 2) {
167  for (unsigned int i = 1; i < timeSpan.size(); ++i) {
168  if (timeSpan[i - 1] > timeSpan[i]) {
169  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': entries of time span must be ordered ascendingly.");
170  }
171  }
172  }
173 
174  SUMOTrafficObject* obj = getTrafficObject(trackedObjectID);
176  PolygonDynamics* pd = shapeCont.addPolygonDynamics(SIMTIME, polygonID, obj, timeSpan, alphaSpan, looped, rotate);
177  if (pd == nullptr) {
178  throw TraCIException("Could not add polygon dynamics for polygon '" + polygonID + "': polygon doesn't exist.");
179  }
180  // Ensure existence of a DynamicShapeUpdater
181  if (MSNet::getInstance()->getDynamicShapeUpdater() == nullptr) {
184  }
185 
186  // Schedule the regular polygon update
188  shapeCont.addPolygonUpdateCommand(pd->getPolygonID(), cmd);
190 }
191 
192 
193 void
194 Polygon::remove(const std::string& polygonID, int /* layer */) {
195  // !!! layer not used yet (shouldn't the id be enough?)
197  if (myTree != nullptr) {
198  SUMOPolygon* p = shapeCont.getPolygons().get(polygonID);
199  if (p != nullptr) {
200  Boundary b = p->getShape().getBoxBoundary();
201  const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
202  const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
203  myTree->Remove(cmin, cmax, p);
204  }
205  }
206  if (!shapeCont.removePolygon(polygonID)) {
207  throw TraCIException("Could not remove polygon '" + polygonID + "'");
208  }
209 }
210 
211 
212 void
213 Polygon::setFilled(std::string polygonID, bool filled) {
214  SUMOPolygon* p = getPolygon(polygonID);
215  p->setFill(filled);
216 }
217 
218 void
219 Polygon::setLineWidth(std::string polygonID, double lineWidth) {
220  SUMOPolygon* p = getPolygon(polygonID);
221  p->setLineWidth(lineWidth);
222 }
223 
224 
226 Polygon::getPolygon(const std::string& id) {
228  if (p == nullptr) {
229  throw TraCIException("Polygon '" + id + "' is not known");
230  }
231  return p;
232 }
233 
234 
236 Polygon::getTrafficObject(const std::string& id) {
237  if (id == "") {
238  return nullptr;
239  }
240  MSNet* net = MSNet::getInstance();
241  // First try to find a vehicle with the given id
242  SUMOVehicle* sumoVehicle = net->getVehicleControl().getVehicle(id);
243  if (sumoVehicle != nullptr) {
244  return static_cast<SUMOTrafficObject*>(sumoVehicle);
245  }
246  MSTransportable* transportable = net->getPersonControl().get(id);
247  if (transportable != nullptr) {
248  return static_cast<SUMOTrafficObject*>(transportable);
249  } else {
250  throw TraCIException("Traffic object '" + id + "' is not known");
251  }
252 }
253 
254 
255 void
256 Polygon::setParameter(const std::string& polygonID, const std::string& key, const std::string& value) {
257  SUMOPolygon* p = getPolygon(polygonID);
258  p->setParameter(key, value);
259 }
260 
261 
263 
264 
265 NamedRTree*
266 Polygon::getTree() {
267  if (myTree == nullptr) {
268  myTree = new NamedRTree();
270  for (const auto& i : shapeCont.getPolygons()) {
271  Boundary b = i.second->getShape().getBoxBoundary();
272  const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
273  const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
274  myTree->Insert(cmin, cmax, i.second);
275  }
276  }
277  return myTree;
278 }
279 
280 void
281 Polygon::cleanup() {
282  delete myTree;
283  myTree = nullptr;
284 }
285 
286 void
287 Polygon::storeShape(const std::string& id, PositionVector& shape) {
288  shape = getPolygon(id)->getShape();
289 }
290 
291 
292 std::shared_ptr<VariableWrapper>
293 Polygon::makeWrapper() {
294  return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
295 }
296 
297 
298 bool
299 Polygon::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
300  switch (variable) {
301  case TRACI_ID_LIST:
302  return wrapper->wrapStringList(objID, variable, getIDList());
303  case ID_COUNT:
304  return wrapper->wrapInt(objID, variable, getIDCount());
305  case VAR_TYPE:
306  return wrapper->wrapString(objID, variable, getType(objID));
307  case VAR_COLOR:
308  return wrapper->wrapColor(objID, variable, getColor(objID));
309  case VAR_FILL:
310  return wrapper->wrapInt(objID, variable, getFilled(objID));
311  case VAR_WIDTH:
312  return wrapper->wrapDouble(objID, variable, getLineWidth(objID));
313  case VAR_SHAPE:
314  return wrapper->wrapPositionVector(objID, variable, getShape(objID));
316  paramData->readUnsignedByte();
317  return wrapper->wrapString(objID, variable, getParameter(objID, paramData->readString()));
319  paramData->readUnsignedByte();
320  return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->readString()));
321  default:
322  return false;
323  }
324 }
325 
326 
327 bool
328 Polygon::exists(std::string polyID) {
330  return p != nullptr;
331 }
332 }
333 
334 
335 /****************************************************************************/
#define SIMSTEP
Definition: SUMOTime.h:59
#define SIMTIME
Definition: SUMOTime.h:60
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
Definition: TraCIDefs.h:69
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
Definition: TraCIDefs.h:115
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:129
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:117
PositionVector getShape(const bool closeShape) const
get position vector (shape) based on this boundary
Definition: Boundary.cpp:387
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:135
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:123
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
Interface for objects listening to vehicle state changes.
Definition: MSNet.h:627
The simulated network and simulation perfomer.
Definition: MSNet.h:88
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:174
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:376
ShapeContainer & getShapeContainer()
Returns the shapes container.
Definition: MSNet.h:499
MSEventControl * getEndOfTimestepEvents()
Returns the event control for events executed at the end of a time step.
Definition: MSNet.h:479
void addVehicleStateListener(VehicleStateListener *listener)
Adds a vehicle states listener.
Definition: MSNet.cpp:1127
MSDynamicShapeUpdater * makeDynamicShapeUpdater()
Creates and returns a dynamic shapes updater.
Definition: MSNet.cpp:1076
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1059
MSTransportable * get(const std::string &id) const
Returns the named transportable, if existing.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
T get(const std::string &id) const
Retrieves an item.
void insertIDs(std::vector< std::string > &into) const
A RT-tree for efficient storing of SUMO's Named objects.
Definition: NamedRTree.h:61
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
A wrapper for a Command function with parameter.
const std::string & getPolygonID() const
A 2D- or 3D-polygon.
Definition: SUMOPolygon.h:34
A list of positions.
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
const PositionVector & getShape() const
Returns whether the shape of the polygon.
Definition: SUMOPolygon.cpp:52
void setFill(bool fill)
Sets whether the polygon shall be filled.
Definition: SUMOPolygon.cpp:70
void setLineWidth(double lineWidth)
set line width
Definition: SUMOPolygon.cpp:76
Representation of a vehicle, person, or container.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
Storage for geometrical objects.
const Polygons & getPolygons() const
Returns all polygons.
virtual SUMOTime polygonDynamicsUpdate(SUMOTime t, PolygonDynamics *pd)
Regular update event for updating polygon dynamics.
virtual void reshapePolygon(const std::string &id, const PositionVector &shape)
Assigns a shape to the named polygon.
virtual bool removePolygon(const std::string &id, bool useLock=true)
Removes a polygon from the container.
virtual bool addPolygon(const std::string &id, const std::string &type, const RGBColor &color, double layer, double angle, const std::string &imgFile, bool relativePath, const PositionVector &shape, bool geo, bool fill, double lineWidth, bool ignorePruning=false, const std::string &name=Shape::DEFAULT_NAME)
Builds a polygon using the given values and adds it to the container.
virtual PolygonDynamics * addPolygonDynamics(double simtime, std::string polyID, SUMOTrafficObject *trackedObject, const std::vector< double > &timeSpan, const std::vector< double > &alphaSpan, bool looped, bool rotate)
Adds dynamics (animation / tracking) to the given polygon.
virtual void addPolygonUpdateCommand(std::string polyID, ParametrisedWrappingCommand< ShapeContainer, PolygonDynamics * > *cmd)
Register update command (for descheduling at removal)
virtual void registerHighlight(const std::string &objectID, const int type, const std::string &polygonID)
register highlight of the specified type if the given id
static const bool DEFAULT_RELATIVEPATH
Definition: Shape.h:47
const RGBColor & getShapeColor() const
Returns the color of the Shape.
Definition: Shape.h:83
static const std::string DEFAULT_IMG_FILE
Definition: Shape.h:46
void setShapeType(const std::string &type)
Sets a new type.
Definition: Shape.h:128
static const double DEFAULT_ANGLE
Definition: Shape.h:45
static PositionVector makePositionVector(const TraCIPositionVector &vector)
Definition: Helper.cpp:348
static TraCIPositionVector makeTraCIPositionVector(const PositionVector &positionVector)
helper functions
Definition: Helper.cpp:338
static TraCIColor makeTraCIColor(const RGBColor &color)
Definition: Helper.cpp:361
static RGBColor makeRGBColor(const TraCIColor &color)
Definition: Helper.cpp:372
virtual std::string readString()
Definition: storage.cpp:180
virtual int readUnsignedByte()
Definition: storage.cpp:155
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_TYPE
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
Definition: TraCIDefs.h:279
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_WIDTH
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
Definition: TraCIDefs.h:278
TRACI_CONST int VAR_SHAPE
TRACI_CONST int ID_COUNT
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_FILL