SUMO - Simulation of Urban MObility
TraCIServerAPI_Vehicle.cpp
Go to the documentation of this file.
1 /****************************************************************************/
13 // APIs for getting/setting vehicle values via TraCI
14 /****************************************************************************/
15 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
16 // Copyright (C) 2009-2015 DLR (http://www.dlr.de/) and contributors
17 /****************************************************************************/
18 //
19 // This file is part of SUMO.
20 // SUMO is free software: you can redistribute it and/or modify
21 // it under the terms of the GNU General Public License as published by
22 // the Free Software Foundation, either version 3 of the License, or
23 // (at your option) any later version.
24 //
25 /****************************************************************************/
26 
27 
28 // ===========================================================================
29 // included modules
30 // ===========================================================================
31 #ifdef _MSC_VER
32 #include <windows_config.h>
33 #else
34 #include <config.h>
35 #endif
36 
37 #ifndef NO_TRACI
38 
39 #include <microsim/MSNet.h>
41 #include <microsim/MSVehicle.h>
42 #include <microsim/MSLane.h>
43 #include <microsim/MSEdge.h>
52 #include "TraCIConstants.h"
54 #include "TraCIServerAPI_Vehicle.h"
56 
57 #ifdef CHECK_MEMORY_LEAKS
58 #include <foreign/nvwa/debug_new.h>
59 #endif // CHECK_MEMORY_LEAKS
60 
61 //#define DEBUG_VTD 1
62 //#define DEBUG_VTD_ANGLE 1
63 
64 
65 // ===========================================================================
66 // static member variables
67 // ===========================================================================
68 std::map<std::string, std::vector<MSLane*> > TraCIServerAPI_Vehicle::gVTDMap;
69 
70 
71 // ===========================================================================
72 // method definitions
73 // ===========================================================================
74 bool
76  tcpip::Storage& outputStorage) {
77  // variable & id
78  int variable = inputStorage.readUnsignedByte();
79  std::string id = inputStorage.readString();
80  // check variable
81  if (variable != ID_LIST && variable != VAR_SPEED && variable != VAR_SPEED_WITHOUT_TRACI
82  && variable != VAR_POSITION && variable != VAR_ANGLE && variable != VAR_POSITION3D
83  && variable != VAR_ROAD_ID && variable != VAR_LANE_ID && variable != VAR_LANE_INDEX
84  && variable != VAR_TYPE && variable != VAR_ROUTE_ID && variable != VAR_COLOR
85  && variable != VAR_LANEPOSITION
86  && variable != VAR_CO2EMISSION && variable != VAR_COEMISSION
87  && variable != VAR_HCEMISSION && variable != VAR_PMXEMISSION
88  && variable != VAR_NOXEMISSION && variable != VAR_FUELCONSUMPTION && variable != VAR_NOISEEMISSION
89  && variable != VAR_PERSON_NUMBER && variable != VAR_LEADER
90  && variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT
91  && variable != VAR_ROUTE_VALID && variable != VAR_EDGES
92  && variable != VAR_SIGNALS && variable != VAR_DISTANCE
93  && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_VEHICLECLASS
94  && variable != VAR_SPEED_FACTOR && variable != VAR_SPEED_DEVIATION
95  && variable != VAR_ALLOWED_SPEED && variable != VAR_EMISSIONCLASS
96  && variable != VAR_WIDTH && variable != VAR_MINGAP && variable != VAR_SHAPECLASS
97  && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_IMPERFECTION
98  && variable != VAR_TAU && variable != VAR_BEST_LANES && variable != DISTANCE_REQUEST
99  && variable != ID_COUNT && variable != VAR_STOPSTATE && variable != VAR_WAITING_TIME
100  && variable != VAR_PARAMETER
101  ) {
102  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Get Vehicle Variable: unsupported variable specified", outputStorage);
103  }
104  // begin response building
105  tcpip::Storage tempMsg;
106  // response-code, variableID, objectID
108  tempMsg.writeUnsignedByte(variable);
109  tempMsg.writeString(id);
110  // process request
111  if (variable == ID_LIST || variable == ID_COUNT) {
112  std::vector<std::string> ids;
114  for (MSVehicleControl::constVehIt i = c.loadedVehBegin(); i != c.loadedVehEnd(); ++i) {
115  if ((*i).second->isOnRoad()) {
116  ids.push_back((*i).first);
117  }
118  }
119  if (variable == ID_LIST) {
121  tempMsg.writeStringList(ids);
122  } else {
124  tempMsg.writeInt((int) ids.size());
125  }
126  } else {
128  if (sumoVehicle == 0) {
129  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not known", outputStorage);
130  }
131  MSVehicle* v = dynamic_cast<MSVehicle*>(sumoVehicle);
132  if (v == 0) {
133  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not a micro-simulation vehicle", outputStorage);
134  }
135  const bool onRoad = v->isOnRoad();
136  switch (variable) {
137  case VAR_SPEED:
139  tempMsg.writeDouble(onRoad ? v->getSpeed() : INVALID_DOUBLE_VALUE);
140  break;
144  break;
145  case VAR_POSITION:
147  tempMsg.writeDouble(onRoad ? v->getPosition().x() : INVALID_DOUBLE_VALUE);
148  tempMsg.writeDouble(onRoad ? v->getPosition().y() : INVALID_DOUBLE_VALUE);
149  break;
150  case VAR_POSITION3D:
152  tempMsg.writeDouble(onRoad ? v->getPosition().x() : INVALID_DOUBLE_VALUE);
153  tempMsg.writeDouble(onRoad ? v->getPosition().y() : INVALID_DOUBLE_VALUE);
154  tempMsg.writeDouble(onRoad ? v->getPosition().z() : INVALID_DOUBLE_VALUE);
155  break;
156  case VAR_ANGLE:
158  tempMsg.writeDouble(onRoad ? v->getAngle() : INVALID_DOUBLE_VALUE);
159  break;
160  case VAR_ROAD_ID:
162  tempMsg.writeString(onRoad ? v->getLane()->getEdge().getID() : "");
163  break;
164  case VAR_LANE_ID:
166  tempMsg.writeString(onRoad ? v->getLane()->getID() : "");
167  break;
168  case VAR_LANE_INDEX:
170  if (onRoad) {
171  const std::vector<MSLane*>& lanes = v->getLane()->getEdge().getLanes();
172  tempMsg.writeInt((int)std::distance(lanes.begin(), std::find(lanes.begin(), lanes.end(), v->getLane())));
173  } else {
174  tempMsg.writeInt(INVALID_INT_VALUE);
175  }
176  break;
177  case VAR_TYPE:
179  tempMsg.writeString(v->getVehicleType().getID());
180  break;
181  case VAR_ROUTE_ID:
183  tempMsg.writeString(v->getRoute().getID());
184  break;
185  case VAR_COLOR:
186  tempMsg.writeUnsignedByte(TYPE_COLOR);
187  tempMsg.writeUnsignedByte(v->getParameter().color.red());
188  tempMsg.writeUnsignedByte(v->getParameter().color.green());
189  tempMsg.writeUnsignedByte(v->getParameter().color.blue());
190  tempMsg.writeUnsignedByte(v->getParameter().color.alpha());
191  break;
192  case VAR_LANEPOSITION:
194  tempMsg.writeDouble(onRoad ? v->getPositionOnLane() : INVALID_DOUBLE_VALUE);
195  break;
196  case VAR_CO2EMISSION:
198  tempMsg.writeDouble(onRoad ? v->getCO2Emissions() : INVALID_DOUBLE_VALUE);
199  break;
200  case VAR_COEMISSION:
202  tempMsg.writeDouble(onRoad ? v->getCOEmissions() : INVALID_DOUBLE_VALUE);
203  break;
204  case VAR_HCEMISSION:
206  tempMsg.writeDouble(onRoad ? v->getHCEmissions() : INVALID_DOUBLE_VALUE);
207  break;
208  case VAR_PMXEMISSION:
210  tempMsg.writeDouble(onRoad ? v->getPMxEmissions() : INVALID_DOUBLE_VALUE);
211  break;
212  case VAR_NOXEMISSION:
214  tempMsg.writeDouble(onRoad ? v->getNOxEmissions() : INVALID_DOUBLE_VALUE);
215  break;
216  case VAR_FUELCONSUMPTION:
218  tempMsg.writeDouble(onRoad ? v->getFuelConsumption() : INVALID_DOUBLE_VALUE);
219  break;
220  case VAR_NOISEEMISSION:
223  break;
224  case VAR_PERSON_NUMBER:
226  tempMsg.writeInt(v->getPersonNumber());
227  break;
228  case VAR_LEADER: {
229  double dist = 0;
230  if (!server.readTypeCheckingDouble(inputStorage, dist)) {
231  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Leader retrieval requires a double.", outputStorage);
232  }
233  std::pair<const MSVehicle* const, SUMOReal> leaderInfo = v->getLeader(dist);
235  tempMsg.writeInt(2);
237  tempMsg.writeString(leaderInfo.first != 0 ? leaderInfo.first->getID() : "");
239  tempMsg.writeDouble(leaderInfo.second);
240  }
241  break;
242  case VAR_WAITING_TIME:
244  tempMsg.writeDouble(v->getWaitingSeconds());
245  break;
246  case VAR_EDGE_TRAVELTIME: {
247  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
248  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires a compound object.", outputStorage);
249  }
250  if (inputStorage.readInt() != 2) {
251  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires time, and edge as parameter.", outputStorage);
252  }
253  // time
254  SUMOTime time = 0;
255  if (!server.readTypeCheckingInt(inputStorage, time)) {
256  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced time as first parameter.", outputStorage);
257  }
258  // edge
259  std::string edgeID;
260  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
261  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires the referenced edge as second parameter.", outputStorage);
262  }
263  MSEdge* edge = MSEdge::dictionary(edgeID);
264  if (edge == 0) {
265  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
266  }
267  // retrieve
269  SUMOReal value;
270  if (!v->getWeightsStorage().retrieveExistingTravelTime(edge, time, value)) {
272  } else {
273  tempMsg.writeDouble(value);
274  }
275 
276  }
277  break;
278  case VAR_EDGE_EFFORT: {
279  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
280  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires a compound object.", outputStorage);
281  }
282  if (inputStorage.readInt() != 2) {
283  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of travel time requires time, and edge as parameter.", outputStorage);
284  }
285  // time
286  SUMOTime time = 0;
287  if (!server.readTypeCheckingInt(inputStorage, time)) {
288  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced time as first parameter.", outputStorage);
289  }
290  // edge
291  std::string edgeID;
292  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
293  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of effort requires the referenced edge as second parameter.", outputStorage);
294  }
295  MSEdge* edge = MSEdge::dictionary(edgeID);
296  if (edge == 0) {
297  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
298  }
299  // retrieve
301  SUMOReal value;
302  if (!v->getWeightsStorage().retrieveExistingEffort(edge, time, value)) {
304  } else {
305  tempMsg.writeDouble(value);
306  }
307 
308  }
309  break;
310  case VAR_ROUTE_VALID: {
311  std::string msg;
312  tempMsg.writeUnsignedByte(TYPE_UBYTE);
313  tempMsg.writeUnsignedByte(v->hasValidRoute(msg));
314  }
315  break;
316  case VAR_EDGES: {
317  const MSRoute& r = v->getRoute();
319  tempMsg.writeInt(r.size());
320  for (MSRouteIterator i = r.begin(); i != r.end(); ++i) {
321  tempMsg.writeString((*i)->getID());
322  }
323  }
324  break;
325  case VAR_SIGNALS:
327  tempMsg.writeInt(v->getSignals());
328  break;
329  case VAR_BEST_LANES: {
331  tcpip::Storage tempContent;
332  unsigned int cnt = 0;
333  tempContent.writeUnsignedByte(TYPE_INTEGER);
334  const std::vector<MSVehicle::LaneQ>& bestLanes = onRoad ? v->getBestLanes() : std::vector<MSVehicle::LaneQ>();
335  tempContent.writeInt((int) bestLanes.size());
336  ++cnt;
337  for (std::vector<MSVehicle::LaneQ>::const_iterator i = bestLanes.begin(); i != bestLanes.end(); ++i) {
338  const MSVehicle::LaneQ& lq = *i;
339  tempContent.writeUnsignedByte(TYPE_STRING);
340  tempContent.writeString(lq.lane->getID());
341  ++cnt;
342  tempContent.writeUnsignedByte(TYPE_DOUBLE);
343  tempContent.writeDouble(lq.length);
344  ++cnt;
345  tempContent.writeUnsignedByte(TYPE_DOUBLE);
346  tempContent.writeDouble(lq.nextOccupation);
347  ++cnt;
348  tempContent.writeUnsignedByte(TYPE_BYTE);
349  tempContent.writeByte(lq.bestLaneOffset);
350  ++cnt;
351  tempContent.writeUnsignedByte(TYPE_UBYTE);
352  lq.allowsContinuation ? tempContent.writeUnsignedByte(1) : tempContent.writeUnsignedByte(0);
353  ++cnt;
354  std::vector<std::string> bestContIDs;
355  for (std::vector<MSLane*>::const_iterator j = lq.bestContinuations.begin(); j != lq.bestContinuations.end(); ++j) {
356  if ((*j) != 0) {
357  bestContIDs.push_back((*j)->getID());
358  }
359  }
360  tempContent.writeUnsignedByte(TYPE_STRINGLIST);
361  tempContent.writeStringList(bestContIDs);
362  ++cnt;
363  }
364  tempMsg.writeInt((int) cnt);
365  tempMsg.writeStorage(tempContent);
366  }
367  break;
368  case VAR_STOPSTATE: {
369  char b = (
370  1 * (v->isStopped() ? 1 : 0) +
371  2 * (v->isParking() ? 1 : 0) +
372  4 * (v->isStoppedTriggered() ? 1 : 0));
373  tempMsg.writeUnsignedByte(TYPE_UBYTE);
374  tempMsg.writeUnsignedByte(b);
375  }
376  break;
377  case VAR_DISTANCE: {
379  SUMOReal distance = onRoad ? v->getRoute().getDistanceBetween(0, v->getPositionOnLane(), v->getRoute().getEdges()[0], &v->getLane()->getEdge()) : INVALID_DOUBLE_VALUE;
380  if (distance == std::numeric_limits<SUMOReal>::max()) {
381  distance = INVALID_DOUBLE_VALUE;
382  }
383  tempMsg.writeDouble(distance);
384  }
385  break;
386  case DISTANCE_REQUEST:
387  if (!commandDistanceRequest(server, inputStorage, tempMsg, v)) {
388  return false;
389  }
390  break;
391  case VAR_ALLOWED_SPEED:
393  tempMsg.writeDouble(onRoad ? v->getLane()->getVehicleMaxSpeed(v) : INVALID_DOUBLE_VALUE);
394  break;
395  case VAR_SPEED_FACTOR:
397  tempMsg.writeDouble(v->getChosenSpeedFactor());
398  break;
399  case VAR_PARAMETER: {
400  std::string paramName = "";
401  if (!server.readTypeCheckingString(inputStorage, paramName)) {
402  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of a parameter requires its name.", outputStorage);
403  }
405  tempMsg.writeString(v->getParameter().getParameter(paramName, ""));
406  }
407  break;
408  default:
410  break;
411  }
412  }
413  server.writeStatusCmd(CMD_GET_VEHICLE_VARIABLE, RTYPE_OK, "", outputStorage);
414  server.writeResponseWithLength(outputStorage, tempMsg);
415  return true;
416 }
417 
418 
419 bool
421  tcpip::Storage& outputStorage) {
422  std::string warning = ""; // additional description for response
423  // variable
424  int variable = inputStorage.readUnsignedByte();
425  if (variable != CMD_STOP && variable != CMD_CHANGELANE
426  && variable != CMD_SLOWDOWN && variable != CMD_CHANGETARGET && variable != CMD_RESUME
427  && variable != VAR_TYPE && variable != VAR_ROUTE_ID && variable != VAR_ROUTE
428  && variable != VAR_EDGE_TRAVELTIME && variable != VAR_EDGE_EFFORT
429  && variable != CMD_REROUTE_TRAVELTIME && variable != CMD_REROUTE_EFFORT
430  && variable != VAR_SIGNALS && variable != VAR_MOVE_TO
431  && variable != VAR_LENGTH && variable != VAR_MAXSPEED && variable != VAR_VEHICLECLASS
432  && variable != VAR_SPEED_FACTOR && variable != VAR_EMISSIONCLASS
433  && variable != VAR_WIDTH && variable != VAR_MINGAP && variable != VAR_SHAPECLASS
434  && variable != VAR_ACCEL && variable != VAR_DECEL && variable != VAR_IMPERFECTION
435  && variable != VAR_TAU && variable != VAR_LANECHANGE_MODE
436  && variable != VAR_SPEED && variable != VAR_SPEEDSETMODE && variable != VAR_COLOR
437  && variable != ADD && variable != ADD_FULL && variable != REMOVE
438  && variable != VAR_MOVE_TO_VTD && variable != VAR_PARAMETER/* && variable != VAR_SPEED_TIME_LINE && variable != VAR_LANE_TIME_LINE*/
439  ) {
440  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Change Vehicle State: unsupported variable specified", outputStorage);
441  }
442  // id
443  std::string id = inputStorage.readString();
444  const bool shouldExist = variable != ADD && variable != ADD_FULL;
446  if (sumoVehicle == 0) {
447  if (shouldExist) {
448  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not known", outputStorage);
449  }
450  }
451  MSVehicle* v = dynamic_cast<MSVehicle*>(sumoVehicle);
452  if (v == 0 && shouldExist) {
453  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Vehicle '" + id + "' is not a micro-simulation vehicle", outputStorage);
454  }
455  switch (variable) {
456  case CMD_STOP: {
457  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
458  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description.", outputStorage);
459  }
460  int compoundSize = inputStorage.readInt();
461  if (compoundSize != 4 && compoundSize != 5) {
462  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Stop needs a compound object description of four of five items.", outputStorage);
463  }
464  // read road map position
465  std::string roadId;
466  if (!server.readTypeCheckingString(inputStorage, roadId)) {
467  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first stop parameter must be the edge id given as a string.", outputStorage);
468  }
469  double pos = 0;
470  if (!server.readTypeCheckingDouble(inputStorage, pos)) {
471  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second stop parameter must be the position along the edge given as a double.", outputStorage);
472  }
473  int laneIndex = 0;
474  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
475  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The third stop parameter must be the lane index given as a byte.", outputStorage);
476  }
477  // waitTime
478  SUMOTime waitTime = 0;
479  if (!server.readTypeCheckingInt(inputStorage, waitTime)) {
480  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "The fourth stop parameter must be the waiting time given as an integer.", outputStorage);
481  }
482  // optional stop flags
483  bool parking = false;
484  bool triggered = false;
485  bool containerTriggered = false;
486  if (compoundSize == 5) {
487  int stopFlags;
488  if (!server.readTypeCheckingByte(inputStorage, stopFlags)) {
489  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fifth stop parameter must be a byte indicating its parking/triggered status.", outputStorage);
490  }
491  parking = ((stopFlags & 1) != 0);
492  triggered = ((stopFlags & 2) != 0);
493  }
494  // check
495  if (pos < 0) {
496  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Position on lane must not be negative.", outputStorage);
497  }
498  // get the actual lane that is referenced by laneIndex
499  MSEdge* road = MSEdge::dictionary(roadId);
500  if (road == 0) {
501  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Unable to retrieve road with given id.", outputStorage);
502  }
503  const std::vector<MSLane*>& allLanes = road->getLanes();
504  if ((laneIndex < 0) || laneIndex >= (int)(allLanes.size())) {
505  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "No lane with index '" + toString(laneIndex) + "' on road '" + roadId + "'.", outputStorage);
506  }
507  // Forward command to vehicle
508  std::string error;
509  if (!v->addTraciStop(allLanes[laneIndex], pos, 0, waitTime, parking, triggered, containerTriggered, error)) {
510  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
511  }
512  }
513  break;
514  case CMD_RESUME: {
515  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
516  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Resuming requires a compound object.", outputStorage);
517  return false;
518  }
519  if (inputStorage.readInt() != 0) {
520  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Resuming should obtain an empty compound object.", outputStorage);
521  return false;
522  }
523  if (!static_cast<MSVehicle*>(v)->hasStops()) {
524  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Failed to resume vehicle '" + v->getID() + "', it has no stops.", outputStorage);
525  return false;
526  }
527  if (!static_cast<MSVehicle*>(v)->resumeFromStopping()) {
528  MSVehicle::Stop& sto = (static_cast<MSVehicle*>(v))->getNextStop();
529  std::ostringstream strs;
530  strs << "reached: " << sto.reached;
531  strs << ", duration:" << sto.duration;
532  strs << ", edge:" << (*sto.edge)->getID();
533  strs << ", startPos: " << sto.startPos;
534  std::string posStr = strs.str();
535  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_ERR, "Failed to resume a non parking vehicle '" + v->getID() + "', " + posStr, outputStorage);
536  return false;
537  }
538  }
539  break;
540  case CMD_CHANGELANE: {
541  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
542  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description.", outputStorage);
543  }
544  if (inputStorage.readInt() != 2) {
545  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description of two items.", outputStorage);
546  }
547  // Lane ID
548  int laneIndex = 0;
549  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
550  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first lane change parameter must be the lane index given as a byte.", outputStorage);
551  }
552  // stickyTime
553  SUMOTime stickyTime = 0;
554  if (!server.readTypeCheckingInt(inputStorage, stickyTime)) {
555  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second lane change parameter must be the duration given as an integer.", outputStorage);
556  }
557  if ((laneIndex < 0) || (laneIndex >= (int)(v->getEdge()->getLanes().size()))) {
558  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "No lane with index '" + toString(laneIndex) + "' on road '" + v->getEdge()->getID() + "'.", outputStorage);
559  }
560  // Forward command to vehicle
561  std::vector<std::pair<SUMOTime, unsigned int> > laneTimeLine;
562  laneTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
563  laneTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep() + stickyTime, laneIndex));
564  v->getInfluencer().setLaneTimeLine(laneTimeLine);
565  }
566  break;
567  /*
568  case VAR_LANE_TIME_LINE: {
569  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
570  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description.", outputStorage);
571  }
572  if (inputStorage.readInt() != 2) {
573  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Lane change needs a compound object description of two items.", outputStorage);
574  }
575  // Lane ID
576  int laneIndex = 0;
577  if (!server.readTypeCheckingByte(inputStorage, laneIndex)) {
578  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first lane change parameter must be the lane index given as a byte.", outputStorage);
579  }
580  // stickyTime
581  SUMOTime stickyTime = 0;
582  if (!server.readTypeCheckingInt(inputStorage, stickyTime)) {
583  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second lane change parameter must be the duration given as an integer.", outputStorage);
584  }
585  if ((laneIndex < 0) || (laneIndex >= (int)(v->getEdge()->getLanes().size()))) {
586  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "No lane existing with given id on the current road", outputStorage);
587  }
588  // Forward command to vehicle
589  std::vector<std::pair<SUMOTime, unsigned int> > laneTimeLine;
590  laneTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
591  laneTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep() + stickyTime, laneIndex));
592  v->getInfluencer().setLaneTimeLine(laneTimeLine);
593  MSVehicle::ChangeRequest req = v->getInfluencer().checkForLaneChanges(MSNet::getInstance()->getCurrentTimeStep(),
594  *v->getEdge(), v->getLaneIndex());
595  v->getLaneChangeModel().requestLaneChange(req);
596  }
597  break;
598  */
599  case CMD_SLOWDOWN: {
600  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
601  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description.", outputStorage);
602  }
603  if (inputStorage.readInt() != 2) {
604  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Slow down needs a compound object description of two items.", outputStorage);
605  }
606  double newSpeed = 0;
607  if (!server.readTypeCheckingDouble(inputStorage, newSpeed)) {
608  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first slow down parameter must be the speed given as a double.", outputStorage);
609  }
610  if (newSpeed < 0) {
611  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Speed must not be negative", outputStorage);
612  }
613  SUMOTime duration = 0;
614  if (!server.readTypeCheckingInt(inputStorage, duration)) {
615  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second slow down parameter must be the duration given as an integer.", outputStorage);
616  }
617  if (duration < 0 || STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep()) + STEPS2TIME(duration) > STEPS2TIME(SUMOTime_MAX - DELTA_T)) {
618  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid time interval", outputStorage);
619  }
620  std::vector<std::pair<SUMOTime, SUMOReal> > speedTimeLine;
621  speedTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep(), v->getSpeed()));
622  speedTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep() + duration, newSpeed));
623  v->getInfluencer().setSpeedTimeLine(speedTimeLine);
624  }
625  break;
626  case CMD_CHANGETARGET: {
627  std::string edgeID;
628  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
629  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Change target requires a string containing the id of the new destination edge as parameter.", outputStorage);
630  }
631  const MSEdge* destEdge = MSEdge::dictionary(edgeID);
632  if (destEdge == 0) {
633  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Can not retrieve road with ID " + edgeID, outputStorage);
634  }
635  // build a new route between the vehicle's current edge and destination edge
636  ConstMSEdgeVector newRoute;
637  const MSEdge* currentEdge = v->getRerouteOrigin();
639  currentEdge, destEdge, (const MSVehicle * const) v, MSNet::getInstance()->getCurrentTimeStep(), newRoute);
640  // replace the vehicle's route by the new one
641  if (!v->replaceRouteEdges(newRoute, v->getLane() == 0)) {
642  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Route replacement failed for " + v->getID(), outputStorage);
643  }
644  }
645  break;
646  case VAR_TYPE: {
647  std::string vTypeID;
648  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
649  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle type id must be given as a string.", outputStorage);
650  }
651  MSVehicleType* vehicleType = MSNet::getInstance()->getVehicleControl().getVType(vTypeID);
652  if (vehicleType == 0) {
653  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle type '" + vTypeID + "' is not known.", outputStorage);
654  }
655  v->replaceVehicleType(vehicleType);
656  }
657  break;
658  case VAR_ROUTE_ID: {
659  std::string rid;
660  if (!server.readTypeCheckingString(inputStorage, rid)) {
661  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The route id must be given as a string.", outputStorage);
662  }
663  const MSRoute* r = MSRoute::dictionary(rid);
664  if (r == 0) {
665  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The route '" + rid + "' is not known.", outputStorage);
666  }
667  if (!v->replaceRoute(r, v->getLane() == 0)) {
668  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Route replacement failed for " + v->getID(), outputStorage);
669  }
670  }
671  break;
672  case VAR_ROUTE: {
673  std::vector<std::string> edgeIDs;
674  if (!server.readTypeCheckingStringList(inputStorage, edgeIDs)) {
675  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "A route must be defined as a list of edge ids.", outputStorage);
676  }
677  ConstMSEdgeVector edges;
678  MSEdge::parseEdgesList(edgeIDs, edges, "<unknown>");
679  if (!v->replaceRouteEdges(edges, v->getLane() == 0)) {
680  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Route replacement failed for " + v->getID(), outputStorage);
681  }
682  }
683  break;
684  case VAR_EDGE_TRAVELTIME: {
685  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
686  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires a compound object.", outputStorage);
687  }
688  int parameterCount = inputStorage.readInt();
689  if (parameterCount == 4) {
690  // begin time
691  SUMOTime begTime = 0, endTime = 0;
692  if (!server.readTypeCheckingInt(inputStorage, begTime)) {
693  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the begin time as first parameter.", outputStorage);
694  }
695  // begin time
696  if (!server.readTypeCheckingInt(inputStorage, endTime)) {
697  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the end time as second parameter.", outputStorage);
698  }
699  // edge
700  std::string edgeID;
701  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
702  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the referenced edge as third parameter.", outputStorage);
703  }
704  MSEdge* edge = MSEdge::dictionary(edgeID);
705  if (edge == 0) {
706  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
707  }
708  // value
709  double value = 0;
710  if (!server.readTypeCheckingDouble(inputStorage, value)) {
711  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 4 parameters requires the travel time as double as fourth parameter.", outputStorage);
712  }
713  // retrieve
714  v->getWeightsStorage().addTravelTime(edge, begTime, endTime, value);
715  } else if (parameterCount == 2) {
716  // edge
717  std::string edgeID;
718  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
719  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the referenced edge as first parameter.", outputStorage);
720  }
721  MSEdge* edge = MSEdge::dictionary(edgeID);
722  if (edge == 0) {
723  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
724  }
725  // value
726  double value = 0;
727  if (!server.readTypeCheckingDouble(inputStorage, value)) {
728  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 2 parameters requires the travel time as second parameter.", outputStorage);
729  }
730  // retrieve
731  while (v->getWeightsStorage().knowsTravelTime(edge)) {
733  }
734  v->getWeightsStorage().addTravelTime(edge, 0, SUMOTime_MAX, value);
735  } else if (parameterCount == 1) {
736  // edge
737  std::string edgeID;
738  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
739  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time using 1 parameter requires the referenced edge as first parameter.", outputStorage);
740  }
741  MSEdge* edge = MSEdge::dictionary(edgeID);
742  if (edge == 0) {
743  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
744  }
745  // retrieve
746  while (v->getWeightsStorage().knowsTravelTime(edge)) {
748  }
749  } else {
750  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting travel time requires 1, 2, or 4 parameters.", outputStorage);
751  }
752  }
753  break;
754  case VAR_EDGE_EFFORT: {
755  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
756  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires a compound object.", outputStorage);
757  }
758  int parameterCount = inputStorage.readInt();
759  if (parameterCount == 4) {
760  // begin time
761  SUMOTime begTime = 0, endTime = 0;
762  if (!server.readTypeCheckingInt(inputStorage, begTime)) {
763  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the begin time as first parameter.", outputStorage);
764  }
765  // begin time
766  if (!server.readTypeCheckingInt(inputStorage, endTime)) {
767  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the end time as second parameter.", outputStorage);
768  }
769  // edge
770  std::string edgeID;
771  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
772  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the referenced edge as third parameter.", outputStorage);
773  }
774  MSEdge* edge = MSEdge::dictionary(edgeID);
775  if (edge == 0) {
776  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
777  }
778  // value
779  double value = 0;
780  if (!server.readTypeCheckingDouble(inputStorage, value)) {
781  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 4 parameters requires the travel time as fourth parameter.", outputStorage);
782  }
783  // retrieve
784  v->getWeightsStorage().addEffort(edge, begTime, endTime, value);
785  } else if (parameterCount == 2) {
786  // edge
787  std::string edgeID;
788  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
789  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the referenced edge as first parameter.", outputStorage);
790  }
791  MSEdge* edge = MSEdge::dictionary(edgeID);
792  if (edge == 0) {
793  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
794  }
795  // value
796  double value = 0;
797  if (!server.readTypeCheckingDouble(inputStorage, value)) {
798  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 2 parameters requires the travel time as second parameter.", outputStorage);
799  }
800  // retrieve
801  while (v->getWeightsStorage().knowsEffort(edge)) {
802  v->getWeightsStorage().removeEffort(edge);
803  }
804  v->getWeightsStorage().addEffort(edge, 0, SUMOTime_MAX, value);
805  } else if (parameterCount == 1) {
806  // edge
807  std::string edgeID;
808  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
809  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort using 1 parameter requires the referenced edge as first parameter.", outputStorage);
810  }
811  MSEdge* edge = MSEdge::dictionary(edgeID);
812  if (edge == 0) {
813  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Referenced edge '" + edgeID + "' is not known.", outputStorage);
814  }
815  // retrieve
816  while (v->getWeightsStorage().knowsEffort(edge)) {
817  v->getWeightsStorage().removeEffort(edge);
818  }
819  } else {
820  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting effort requires 1, 2, or 4 parameters.", outputStorage);
821  }
822  }
823  break;
824  case CMD_REROUTE_TRAVELTIME: {
825  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
826  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
827  }
828  if (inputStorage.readInt() != 0) {
829  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
830  }
831  v->reroute(MSNet::getInstance()->getCurrentTimeStep(), MSNet::getInstance()->getRouterTT());
832  }
833  break;
834  case CMD_REROUTE_EFFORT: {
835  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
836  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting requires a compound object.", outputStorage);
837  }
838  if (inputStorage.readInt() != 0) {
839  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Rerouting should obtain an empty compound object.", outputStorage);
840  }
841  v->reroute(MSNet::getInstance()->getCurrentTimeStep(), MSNet::getInstance()->getRouterEffort());
842  }
843  break;
844  case VAR_SIGNALS: {
845  int signals = 0;
846  if (!server.readTypeCheckingInt(inputStorage, signals)) {
847  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting signals requires an integer.", outputStorage);
848  }
849  v->switchOffSignal(0x0fffffff);
850  v->switchOnSignal(signals);
851  }
852  break;
853  case VAR_MOVE_TO: {
854  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
855  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting position requires a compound object.", outputStorage);
856  }
857  if (inputStorage.readInt() != 2) {
858  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting position should obtain the lane id and the position.", outputStorage);
859  }
860  // lane ID
861  std::string laneID;
862  if (!server.readTypeCheckingString(inputStorage, laneID)) {
863  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first parameter for setting a position must be the lane ID given as a string.", outputStorage);
864  }
865  // position on lane
866  double position = 0;
867  if (!server.readTypeCheckingDouble(inputStorage, position)) {
868  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second parameter for setting a position must be the position given as a double.", outputStorage);
869  }
870  // process
871  MSLane* l = MSLane::dictionary(laneID);
872  if (l == 0) {
873  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Unknown lane '" + laneID + "'.", outputStorage);
874  }
875  MSEdge& destinationEdge = l->getEdge();
876  if (!v->willPass(&destinationEdge)) {
877  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Vehicle '" + laneID + "' may be set onto an edge to pass only.", outputStorage);
878  }
881  while (v->getEdge() != &destinationEdge) {
882  const MSEdge* nextEdge = v->succEdge(1);
883  // let the vehicle move to the next edge
884  if (v->enterLaneAtMove(nextEdge->getLanes()[0], true)) {
886  continue;
887  }
888  }
889  l->forceVehicleInsertion(v, position);
890  }
891  break;
892  case VAR_SPEED: {
893  double speed = 0;
894  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
895  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed requires a double.", outputStorage);
896  }
897  std::vector<std::pair<SUMOTime, SUMOReal> > speedTimeLine;
898  if (speed >= 0) {
899  speedTimeLine.push_back(std::make_pair(MSNet::getInstance()->getCurrentTimeStep(), speed));
900  speedTimeLine.push_back(std::make_pair(SUMOTime_MAX - DELTA_T, speed));
901  }
902  v->getInfluencer().setSpeedTimeLine(speedTimeLine);
903  }
904  break;
905  case VAR_SPEEDSETMODE: {
906  int speedMode = 0;
907  if (!server.readTypeCheckingInt(inputStorage, speedMode)) {
908  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed mode requires an integer.", outputStorage);
909  }
910  v->getInfluencer().setConsiderSafeVelocity((speedMode & 1) != 0);
911  v->getInfluencer().setConsiderMaxAcceleration((speedMode & 2) != 0);
912  v->getInfluencer().setConsiderMaxDeceleration((speedMode & 4) != 0);
913  v->getInfluencer().setRespectJunctionPriority((speedMode & 8) != 0);
914  v->getInfluencer().setEmergencyBrakeRedLight((speedMode & 16) != 0);
915  }
916  break;
917  case VAR_LANECHANGE_MODE: {
918  int laneChangeMode = 0;
919  if (!server.readTypeCheckingInt(inputStorage, laneChangeMode)) {
920  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting lane change mode requires an integer.", outputStorage);
921  }
922  v->getInfluencer().setLaneChangeMode(laneChangeMode);
923  }
924  break;
925  case VAR_COLOR: {
926  RGBColor col;
927  if (!server.readTypeCheckingColor(inputStorage, col)) {
928  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The color must be given using the according type.", outputStorage);
929  }
930  v->getParameter().color.set(col.red(), col.green(), col.blue(), col.alpha());
932  }
933  break;
934  case ADD: {
935  if (v != 0) {
936  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle " + id + " to add already exists.", outputStorage);
937  }
938  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
939  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
940  }
941  if (inputStorage.readInt() != 6) {
942  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle needs six parameters.", outputStorage);
943  }
944  SUMOVehicleParameter vehicleParams;
945  vehicleParams.id = id;
946 
947  std::string vTypeID;
948  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
949  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
950  }
951  MSVehicleType* vehicleType = MSNet::getInstance()->getVehicleControl().getVType(vTypeID);
952  if (!vehicleType) {
953  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid type '" + vTypeID + "' for vehicle '" + id + "'", outputStorage);
954  }
955 
956  std::string routeID;
957  if (!server.readTypeCheckingString(inputStorage, routeID)) {
958  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
959  }
960  const MSRoute* route = MSRoute::dictionary(routeID);
961  if (!route) {
962  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid route '" + routeID + "' for vehicle: '" + id + "'", outputStorage);
963  }
964 
965  if (!server.readTypeCheckingInt(inputStorage, vehicleParams.depart)) {
966  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an integer.", outputStorage);
967  }
968  if (vehicleParams.depart < 0) {
969  const int proc = static_cast<int>(-vehicleParams.depart);
970  if (proc >= static_cast<int>(DEPART_DEF_MAX)) {
971  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid departure time.", outputStorage);
972  }
973  vehicleParams.departProcedure = (DepartDefinition)proc;
974  } else if (vehicleParams.depart < MSNet::getInstance()->getCurrentTimeStep()) {
975  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Departure time in the past.", outputStorage);
976  }
977 
978  double pos;
979  if (!server.readTypeCheckingDouble(inputStorage, pos)) {
980  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (position) requires a double.", outputStorage);
981  }
982  vehicleParams.departPos = pos;
983  if (vehicleParams.departPos < 0) {
984  const int proc = static_cast<int>(-vehicleParams.departPos);
985  if (fabs(proc + vehicleParams.departPos) > NUMERICAL_EPS || proc >= static_cast<int>(DEPART_POS_DEF_MAX) || proc == static_cast<int>(DEPART_POS_GIVEN)) {
986  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid departure position.", outputStorage);
987  }
988  vehicleParams.departPosProcedure = (DepartPosDefinition)proc;
989  } else {
990  vehicleParams.departPosProcedure = DEPART_POS_GIVEN;
991  }
992 
993  double speed;
994  if (!server.readTypeCheckingDouble(inputStorage, speed)) {
995  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (speed) requires a double.", outputStorage);
996  }
997  vehicleParams.departSpeed = speed;
998  if (vehicleParams.departSpeed < 0) {
999  const int proc = static_cast<int>(-vehicleParams.departSpeed);
1000  if (proc >= static_cast<int>(DEPART_SPEED_DEF_MAX)) {
1001  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid departure speed.", outputStorage);
1002  }
1003  vehicleParams.departSpeedProcedure = (DepartSpeedDefinition)proc;
1004  } else {
1005  vehicleParams.departSpeedProcedure = DEPART_SPEED_GIVEN;
1006  }
1007 
1008  if (!server.readTypeCheckingByte(inputStorage, vehicleParams.departLane)) {
1009  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (lane) requires a byte.", outputStorage);
1010  }
1011 
1012  if (vehicleParams.departLane < 0) {
1013  const int proc = static_cast<int>(-vehicleParams.departLane);
1014  if (proc >= static_cast<int>(DEPART_LANE_DEF_MAX)) {
1015  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid departure lane.", outputStorage);
1016  }
1017  vehicleParams.departLaneProcedure = (DepartLaneDefinition)proc;
1018  } else {
1019  vehicleParams.departLaneProcedure = DEPART_LANE_GIVEN;
1020  }
1021 
1022  SUMOVehicleParameter* params = new SUMOVehicleParameter(vehicleParams);
1023  try {
1024  SUMOVehicle* vehicle = MSNet::getInstance()->getVehicleControl().buildVehicle(params, route, vehicleType, true, false);
1025  MSNet::getInstance()->getVehicleControl().addVehicle(vehicleParams.id, vehicle);
1027  } catch (ProcessError& e) {
1028  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1029  }
1030  }
1031  break;
1032  case ADD_FULL: {
1033  if (v != 0) {
1034  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The vehicle " + id + " to add already exists.", outputStorage);
1035  }
1036  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1037  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a vehicle requires a compound object.", outputStorage);
1038  }
1039  if (inputStorage.readInt() != 14) {
1040  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Adding a fully specified vehicle needs fourteen parameters.", outputStorage);
1041  }
1042  SUMOVehicleParameter vehicleParams;
1043  vehicleParams.id = id;
1044 
1045  std::string routeID;
1046  if (!server.readTypeCheckingString(inputStorage, routeID)) {
1047  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Second parameter (route) requires a string.", outputStorage);
1048  }
1049  const MSRoute* route = MSRoute::dictionary(routeID);
1050  if (!route) {
1051  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid route '" + routeID + "' for vehicle: '" + id + "'", outputStorage);
1052  }
1053 
1054  std::string vTypeID;
1055  if (!server.readTypeCheckingString(inputStorage, vTypeID)) {
1056  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "First parameter (type) requires a string.", outputStorage);
1057  }
1058  MSVehicleType* vehicleType = MSNet::getInstance()->getVehicleControl().getVType(vTypeID);
1059  if (!vehicleType) {
1060  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Invalid type '" + vTypeID + "' for vehicle '" + id + "'", outputStorage);
1061  }
1062 
1063  std::string helper;
1064  std::string error;
1065  if (!server.readTypeCheckingString(inputStorage, helper)) {
1066  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Third parameter (depart) requires an string.", outputStorage);
1067  }
1068  if (!SUMOVehicleParameter::parseDepart(helper, "vehicle", id, vehicleParams.depart, vehicleParams.departProcedure, error)) {
1069  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1070  }
1071  if (vehicleParams.departProcedure == DEPART_GIVEN && vehicleParams.depart < MSNet::getInstance()->getCurrentTimeStep()) {
1072  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Departure time in the past.", outputStorage);
1073  }
1074 
1075  if (!server.readTypeCheckingString(inputStorage, helper)) {
1076  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fourth parameter (depart lane) requires a string.", outputStorage);
1077  }
1078  if (!SUMOVehicleParameter::parseDepartLane(helper, "vehicle", id, vehicleParams.departLane, vehicleParams.departLaneProcedure, error)) {
1079  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1080  }
1081  if (!server.readTypeCheckingString(inputStorage, helper)) {
1082  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Fifth parameter (depart position) requires a string.", outputStorage);
1083  }
1084  if (!SUMOVehicleParameter::parseDepartPos(helper, "vehicle", id, vehicleParams.departPos, vehicleParams.departPosProcedure, error)) {
1085  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1086  }
1087  if (!server.readTypeCheckingString(inputStorage, helper)) {
1088  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Sixth parameter (depart speed) requires a string.", outputStorage);
1089  }
1090  if (!SUMOVehicleParameter::parseDepartSpeed(helper, "vehicle", id, vehicleParams.departSpeed, vehicleParams.departSpeedProcedure, error)) {
1091  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1092  }
1093 
1094  if (!server.readTypeCheckingString(inputStorage, helper)) {
1095  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Seventh parameter (arrival lane) requires a string.", outputStorage);
1096  }
1097  if (!SUMOVehicleParameter::parseArrivalLane(helper, "vehicle", id, vehicleParams.arrivalLane, vehicleParams.arrivalLaneProcedure, error)) {
1098  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1099  }
1100  if (!server.readTypeCheckingString(inputStorage, helper)) {
1101  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Eighth parameter (arrival position) requires a string.", outputStorage);
1102  }
1103  if (!SUMOVehicleParameter::parseArrivalPos(helper, "vehicle", id, vehicleParams.arrivalPos, vehicleParams.arrivalPosProcedure, error)) {
1104  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1105  }
1106  if (!server.readTypeCheckingString(inputStorage, helper)) {
1107  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Ninth parameter (arrival speed) requires a string.", outputStorage);
1108  }
1109  if (!SUMOVehicleParameter::parseArrivalSpeed(helper, "vehicle", id, vehicleParams.arrivalSpeed, vehicleParams.arrivalSpeedProcedure, error)) {
1110  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, error, outputStorage);
1111  }
1112 
1113  if (!server.readTypeCheckingString(inputStorage, vehicleParams.fromTaz)) {
1114  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Tenth parameter (from taz) requires a string.", outputStorage);
1115  }
1116  if (!server.readTypeCheckingString(inputStorage, vehicleParams.toTaz)) {
1117  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Eleventh parameter (to taz) requires a string.", outputStorage);
1118  }
1119  if (!server.readTypeCheckingString(inputStorage, vehicleParams.line)) {
1120  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Twelth parameter (line) requires a string.", outputStorage);
1121  }
1122 
1123  int num;
1124  if (!server.readTypeCheckingInt(inputStorage, num)) {
1125  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "13th parameter (person capacity) requires an int.", outputStorage);
1126  }
1127  vehicleParams.personCapacity = num;
1128  if (!server.readTypeCheckingInt(inputStorage, num)) {
1129  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "14th parameter (person number) requires an int.", outputStorage);
1130  }
1131  vehicleParams.personNumber = num;
1132 
1133  SUMOVehicleParameter* params = new SUMOVehicleParameter(vehicleParams);
1134  try {
1135  SUMOVehicle* vehicle = MSNet::getInstance()->getVehicleControl().buildVehicle(params, route, vehicleType, true, false);
1136  MSNet::getInstance()->getVehicleControl().addVehicle(vehicleParams.id, vehicle);
1138  } catch (ProcessError& e) {
1139  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1140  }
1141  }
1142  break;
1143  case REMOVE: {
1144  int why = 0;
1145  if (!server.readTypeCheckingByte(inputStorage, why)) {
1146  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Removing a vehicle requires a byte.", outputStorage);
1147  }
1149  switch (why) {
1150  case REMOVE_TELEPORT:
1151  // XXX semantics unclear
1152  // n = MSMoveReminder::NOTIFICATION_TELEPORT;
1154  break;
1155  case REMOVE_PARKING:
1156  // XXX semantics unclear
1157  // n = MSMoveReminder::NOTIFICATION_PARKING;
1159  break;
1160  case REMOVE_ARRIVED:
1162  break;
1163  case REMOVE_VAPORIZED:
1165  break;
1168  break;
1169  default:
1170  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Unknown removal status.", outputStorage);
1171  }
1172  if (v->hasDeparted()) {
1173  v->onRemovalFromNet(n);
1174  if (v->getLane() != 0) {
1175  v->getLane()->removeVehicle(v, n);
1176  }
1178  }
1179  }
1180  break;
1181  case VAR_MOVE_TO_VTD: {
1182  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1183  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting VTD vehicle requires a compound object.", outputStorage);
1184  }
1185  if (inputStorage.readInt() != 5) {
1186  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting VTD vehicle should obtain: edgeID, lane, x, y, angle.", outputStorage);
1187  }
1188  // edge ID
1189  std::string edgeID;
1190  if (!server.readTypeCheckingString(inputStorage, edgeID)) {
1191  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The first parameter for setting a VTD vehicle must be the edge ID given as a string.", outputStorage);
1192  }
1193  // lane index
1194  int laneNum = 0;
1195  if (!server.readTypeCheckingInt(inputStorage, laneNum)) {
1196  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The second parameter for setting a VTD vehicle must be lane given as an int.", outputStorage);
1197  }
1198  // x
1199  double x = 0, y = 0, angle = 0;
1200  if (!server.readTypeCheckingDouble(inputStorage, x)) {
1201  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The third parameter for setting a VTD vehicle must be the x-position given as a double.", outputStorage);
1202  }
1203  // y
1204  if (!server.readTypeCheckingDouble(inputStorage, y)) {
1205  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fourth parameter for setting a VTD vehicle must be the y-position given as a double.", outputStorage);
1206  }
1207  // angle
1208  if (!server.readTypeCheckingDouble(inputStorage, angle)) {
1209  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The fifth parameter for setting a VTD vehicle must be the angle given as a double.", outputStorage);
1210  }
1211  // process
1212  if (!v->isOnRoad()) {
1213  break;
1214  }
1215  std::string origID = edgeID + " " + toString(laneNum);
1216  if (laneNum < 0) {
1217  edgeID = '-' + edgeID;
1218  laneNum = -laneNum;
1219  }
1220  Position pos(x, y);
1221  angle *= -1.;
1222  if (fabs(angle) > 180.) {
1223  angle = 180. - angle;
1224  }
1225 
1226  Position vehPos = v->getPosition();
1227  v->getBestLanes();
1228 #ifdef DEBUG_VTD
1229  std::cout << std::endl << "begin vehicle " << v->getID() << " vehPos:" << vehPos << " lane:" << v->getLane()->getID() << std::endl;
1230  std::cout << " want pos:" << pos << " edge:" << edgeID << " laneNum:" << laneNum << " angle:" << angle << std::endl;
1231 #endif
1232 
1233  ConstMSEdgeVector edges;
1234  MSLane* lane = 0;
1235  SUMOReal lanePos;
1237  int routeOffset = 0;
1238  // case a): edge/lane is known and matches route
1239  bool dFound = vtdMap(pos, origID, angle, *v, server, bestDistance, &lane, lanePos, routeOffset, edges);
1240  //
1241  SUMOReal maxRouteDistance = 100;
1242  /*
1243  if (cFound && (bestDistanceA > maxRouteDistance && bestDistanceC > maxRouteDistance)) {
1244  // both route-based approach yield in a position too far away from the submitted --> new route!?
1245  server.setVTDControlled(v, laneC, lanePosC, routeOffsetC, edgesC);
1246  } else {
1247  */
1248  // use the best we have
1249  if (dFound && maxRouteDistance > bestDistance) {
1250  server.setVTDControlled(v, lane, lanePos, routeOffset, edges, MSNet::getInstance()->getCurrentTimeStep());
1251  } else {
1252  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Could not map vehicle '" + id + "'.", outputStorage);
1253  }
1254  //}
1255  }
1256  break;
1257  case VAR_SPEED_FACTOR: {
1258  double factor = 0;
1259  if (!server.readTypeCheckingDouble(inputStorage, factor)) {
1260  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "Setting speed factor requires a double.", outputStorage);
1261  }
1262  v->setChosenSpeedFactor(factor);
1263  }
1264  break;
1265  case VAR_PARAMETER: {
1266  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1267  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "A compound object is needed for setting a parameter.", outputStorage);
1268  }
1269  //readt itemNo
1270  inputStorage.readInt();
1271  std::string name;
1272  if (!server.readTypeCheckingString(inputStorage, name)) {
1273  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The name of the parameter must be given as a string.", outputStorage);
1274  }
1275  std::string value;
1276  if (!server.readTypeCheckingString(inputStorage, value)) {
1277  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, "The value of the parameter must be given as a string.", outputStorage);
1278  }
1279  ((SUMOVehicleParameter&) v->getParameter()).addParameter(name, value);
1280  }
1281  break;
1282  default:
1283  try {
1284  if (!TraCIServerAPI_VehicleType::setVariable(CMD_SET_VEHICLE_VARIABLE, variable, getSingularType(v), server, inputStorage, outputStorage)) {
1285  return false;
1286  }
1287  } catch (ProcessError& e) {
1288  return server.writeErrorStatusCmd(CMD_SET_VEHICLE_VARIABLE, e.what(), outputStorage);
1289  }
1290  break;
1291  }
1292  server.writeStatusCmd(CMD_SET_VEHICLE_VARIABLE, RTYPE_OK, warning, outputStorage);
1293  return true;
1294 }
1295 
1296 
1297 bool
1298 TraCIServerAPI_Vehicle::vtdMap(const Position& pos, const std::string& origID, const SUMOReal angle, MSVehicle& v, TraCIServer& server,
1299  SUMOReal& bestDistance, MSLane** lane, SUMOReal& lanePos, int& routeOffset, ConstMSEdgeVector& edges) {
1300  SUMOReal speed = pos.distanceTo2D(v.getPosition()); // !!!v.getSpeed();
1301  std::set<std::string> into;
1302  PositionVector shape;
1303  shape.push_back(pos);
1304  server.collectObjectsInRange(CMD_GET_EDGE_VARIABLE, shape, speed * 2, into);
1305  SUMOReal maxDist = 0;
1306  std::map<MSLane*, LaneUtility> lane2utility;
1307  for (std::set<std::string>::const_iterator j = into.begin(); j != into.end(); ++j) {
1308  MSEdge* e = MSEdge::dictionary(*j);
1309  const MSEdge* prevEdge = 0;
1310  const MSEdge* nextEdge = 0;
1312  bool onRoute = false;
1313  if (ef != MSEdge::EDGEFUNCTION_INTERNAL) {
1314  const ConstMSEdgeVector& ev = v.getRoute().getEdges();
1315  unsigned int routePosition = v.getRoutePosition();
1317  ++routePosition;
1318  }
1319  ConstMSEdgeVector::const_iterator edgePos = std::find(ev.begin() + routePosition, ev.end(), e);
1320  onRoute = edgePos != ev.end();
1321  if (edgePos == ev.end() - 1 && v.getEdge() == e) {
1322  onRoute &= v.getEdge()->getLanes()[0]->getLength() > v.getPositionOnLane() + SPEED2DIST(speed);
1323  }
1324  prevEdge = e;
1325  nextEdge = !onRoute || edgePos == ev.end() - 1 ? 0 : *(edgePos + 1);
1326  } else {
1327  prevEdge = e;
1328  while (prevEdge != 0 && prevEdge->getPurpose() == MSEdge::EDGEFUNCTION_INTERNAL) {
1329  MSLane* l = prevEdge->getLanes()[0];
1330  l = l->getLogicalPredecessorLane();
1331  prevEdge = l == 0 ? 0 : &l->getEdge();
1332  }
1333  const ConstMSEdgeVector& ev = v.getRoute().getEdges();
1334  ConstMSEdgeVector::const_iterator prevEdgePos = std::find(ev.begin() + v.getRoutePosition(), ev.end(), prevEdge);
1335  if (prevEdgePos != ev.end() && ev.size() > 1 && prevEdgePos != ev.end() - 1) {
1336  const MSJunction* junction = e->getFromJunction();
1337  const ConstMSEdgeVector& outgoing = junction->getOutgoing();
1338  ConstMSEdgeVector::const_iterator nextEdgePos = std::find(outgoing.begin(), outgoing.end(), *(ev.begin() + v.getRoutePosition() + 1));
1339  if (nextEdgePos != outgoing.end()) {
1340  nextEdge = *nextEdgePos;
1341  onRoute = true;
1342  }
1343  }
1344  }
1345 
1346 
1347  const std::vector<MSLane*>& lanes = e->getLanes();
1348  for (std::vector<MSLane*>::const_iterator k = lanes.begin(); k != lanes.end(); ++k) {
1349  MSLane* lane = *k;
1350  SUMOReal off = lane->getShape().nearest_offset_to_point2D(pos);
1351  SUMOReal langle = 180.;
1352  SUMOReal dist = 1000.;
1353  if (off >= 0) {
1354  dist = lane->getShape().distance(pos);
1355  if (dist > lane->getLength()) { // this is a workaround
1356  // a SmartDB, running at :49_2 delivers off=~9.24 while dist>24.?
1357  dist = 1000.;
1358  } else {
1359  langle = lane->getShape().rotationDegreeAtOffset(off);
1360  }
1361  }
1362  maxDist = MAX2(maxDist, dist);
1363  bool sameEdge = &lane->getEdge() == &v.getLane()->getEdge() && v.getEdge()->getLanes()[0]->getLength() > v.getPositionOnLane() + SPEED2DIST(speed);
1364  const MSEdge* rNextEdge = nextEdge;
1365  if (rNextEdge == 0 && lane->getEdge().getPurpose() == MSEdge::EDGEFUNCTION_INTERNAL) {
1366  MSLane* next = lane->getLinkCont()[0]->getLane();
1367  rNextEdge = next == 0 ? 0 : &next->getEdge();
1368  }
1369 #ifdef DEBUG_VTD_ANGLE
1370  std::cout << lane->getID() << ": " << langle << " " << off << std::endl;
1371 #endif
1372  lane2utility[lane] = LaneUtility(
1373  dist, GeomHelper::getMinAngleDiff(angle, langle),
1374  lane->getParameter("origId", "") == origID,
1375  onRoute, sameEdge, prevEdge, rNextEdge);
1376  }
1377  }
1378 
1379  SUMOReal bestValue = 0;
1380  MSLane* bestLane = 0;
1381  for (std::map<MSLane*, LaneUtility>::iterator i = lane2utility.begin(); i != lane2utility.end(); ++i) {
1382  MSLane* l = (*i).first;
1383  const LaneUtility& u = (*i).second;
1384  SUMOReal distN = u.dist > 999 ? -10 : 1. - (u.dist / maxDist);
1385  SUMOReal angleDiffN = 1. - (u.angleDiff / 180.);
1386  SUMOReal idN = u.ID ? 1 : 0;
1387  SUMOReal onRouteN = u.onRoute ? 1 : 0;
1388  SUMOReal sameEdgeN = u.sameEdge ? MIN2(v.getEdge()->getLength() / speed, (SUMOReal)1.) : 0;
1389  SUMOReal value = distN * .5
1390  + angleDiffN * 0 /*.5 */
1391  + idN * .5
1392  + onRouteN * 0.5
1393  + sameEdgeN * 0.5
1394  ;
1395 #ifdef DEBUG_VTD
1396  std::cout << " x; l:" << l->getID() << " d:" << u.dist << " dN:" << distN << " aD:" << angleDiffN <<
1397  " ID:" << idN << " oRN:" << onRouteN << " sEN:" << sameEdgeN << " value:" << value << std::endl;
1398 #endif
1399  if (value > bestValue || bestLane == 0) {
1400  bestValue = value;
1401  bestLane = l;
1402  }
1403  }
1404  if (bestLane == 0) {
1405  return false;
1406  }
1407  const LaneUtility& u = lane2utility.find(bestLane)->second;
1408  bestDistance = u.dist;
1409  *lane = bestLane;
1410  lanePos = bestLane->getShape().nearest_offset_to_point2D(pos);
1411  const MSEdge* prevEdge = u.prevEdge;
1412  if (u.onRoute) {
1413  const ConstMSEdgeVector& ev = v.getRoute().getEdges();
1414  ConstMSEdgeVector::const_iterator prevEdgePos = std::find(ev.begin() + v.getRoutePosition(), ev.end(), prevEdge);
1415  routeOffset = (int)std::distance(ev.begin(), prevEdgePos) - v.getRoutePosition();
1416  } else {
1417  edges.push_back(prevEdge);
1418  if (u.nextEdge != 0) {
1419  edges.push_back(u.nextEdge);
1420  }
1421  routeOffset = 0;
1422  }
1423  return true;
1424 }
1425 
1426 bool
1428  tcpip::Storage& outputStorage, const MSVehicle* v) {
1429  if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
1430  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage);
1431  }
1432  if (inputStorage.readInt() != 2) {
1433  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Retrieval of distance requires position and distance type as parameter.", outputStorage);
1434  }
1435 
1436  Position pos;
1437  std::pair<const MSLane*, SUMOReal> roadPos;
1438 
1439  // read position
1440  int posType = inputStorage.readUnsignedByte();
1441  switch (posType) {
1442  case POSITION_ROADMAP:
1443  try {
1444  std::string roadID = inputStorage.readString();
1445  roadPos.second = inputStorage.readDouble();
1446  roadPos.first = TraCIServerAPI_Simulation::getLaneChecking(roadID, inputStorage.readUnsignedByte(), roadPos.second);
1447  pos = roadPos.first->getShape().positionAtOffset(roadPos.second);
1448  } catch (TraCIException& e) {
1449  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, e.what(), outputStorage);
1450  }
1451  break;
1452  case POSITION_2D:
1453  case POSITION_3D: {
1454  const double p1x = inputStorage.readDouble();
1455  const double p1y = inputStorage.readDouble();
1456  pos.set(p1x, p1y);
1457  }
1458  if (posType == POSITION_3D) {
1459  inputStorage.readDouble(); // z value is ignored
1460  }
1462  break;
1463  default:
1464  return server.writeErrorStatusCmd(CMD_GET_VEHICLE_VARIABLE, "Unknown position format used for distance request", outputStorage);
1465  }
1466 
1467  // read distance type
1468  int distType = inputStorage.readUnsignedByte();
1469 
1470  SUMOReal distance = INVALID_DOUBLE_VALUE;
1471  if (v->isOnRoad()) {
1472  if (distType == REQUEST_DRIVINGDIST) {
1473  distance = v->getRoute().getDistanceBetween(v->getPositionOnLane(), roadPos.second,
1474  v->getEdge(), &roadPos.first->getEdge());
1475  if (distance == std::numeric_limits<SUMOReal>::max()) {
1476  distance = INVALID_DOUBLE_VALUE;
1477  }
1478  } else {
1479  // compute air distance (default)
1480  distance = v->getPosition().distanceTo(pos);
1481  }
1482  }
1483  // write response command
1484  outputStorage.writeUnsignedByte(TYPE_DOUBLE);
1485  outputStorage.writeDouble(distance);
1486  return true;
1487 }
1488 
1489 
1490 // ------ helper functions ------
1491 bool
1492 TraCIServerAPI_Vehicle::getPosition(const std::string& id, Position& p) {
1493  MSVehicle* v = dynamic_cast<MSVehicle*>(MSNet::getInstance()->getVehicleControl().getVehicle(id));
1494  if (v == 0) {
1495  return false;
1496  }
1497  p = v->getPosition();
1498  return true;
1499 }
1500 
1501 
1504  const MSVehicleType& oType = veh->getVehicleType();
1505  std::string newID = oType.getID().find('@') == std::string::npos ? oType.getID() + "@" + veh->getID() : oType.getID();
1506  MSVehicleType* type = MSVehicleType::build(newID, &oType);
1507  static_cast<MSVehicle*>(veh)->replaceVehicleType(type);
1508  return *type;
1509 }
1510 
1511 
1512 #include <microsim/MSEdgeControl.h>
1513 
1514 const std::map<std::string, std::vector<MSLane*> >&
1516  if (gVTDMap.size() == 0) {
1518  for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
1519  const std::vector<MSLane*>& lanes = (*i)->getLanes();
1520  for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
1521  if ((*j)->knowsParameter("origId")) {
1522  std::string origID = (*j)->getParameter("origId", "");
1523  if (gVTDMap.find(origID) == gVTDMap.end()) {
1524  gVTDMap[origID] = std::vector<MSLane*>();
1525  }
1526  gVTDMap[origID].push_back(*j);
1527  }
1528  }
1529  }
1530  if (gVTDMap.size() == 0) {
1531  gVTDMap["unknown"] = std::vector<MSLane*>();
1532  }
1533  }
1534  return gVTDMap;
1535 }
1536 
1537 
1538 #endif
1539 
1540 
1541 /****************************************************************************/
1542 
#define VAR_ROAD_ID
void forceVehicleInsertion(MSVehicle *veh, SUMOReal pos)
Inserts the given vehicle at the given position.
Definition: MSLane.cpp:626
static bool setVariable(const int cmd, const int variable, MSVehicleType &v, TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value for the given type.
#define REMOVE_PARKING
void replaceVehicleType(MSVehicleType *type)
Replaces the current vehicle type by the one given.
Definition: MSVehicle.cpp:2408
bool enterLaneAtMove(MSLane *enteredLane, bool onTeleporting=false)
Update when the vehicle enters a new lane in the move step.
Definition: MSVehicle.cpp:1727
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:455
RGBColor color
The vehicle's color.
static bool commandDistanceRequest(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage, const MSVehicle *v)
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:80
#define VAR_EMISSIONCLASS
#define VAR_CO2EMISSION
#define REQUEST_DRIVINGDIST
SUMOReal distance(const Position &p, bool perpendicular=false) const
#define VAR_LENGTH
void collectObjectsInRange(int domain, const PositionVector &shape, SUMOReal range, std::set< std::string > &into)
The time is given.
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, SUMOReal &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
#define SPEED2DIST(x)
Definition: SUMOTime.h:55
#define RESPONSE_GET_VEHICLE_VARIABLE
SUMOReal nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
static MSVehicleType & getSingularType(SUMOVehicle *const veh)
#define CMD_GET_VEHICLE_VARIABLE
#define TYPE_COMPOUND
static std::map< std::string, std::vector< MSLane * > > gVTDMap
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
#define CMD_RESUME
#define POSITION_2D
static bool processSet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a set value command (Command 0xc4: Change Vehicle State)
#define VAR_POSITION
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:186
static const MSLane * getLaneChecking(std::string roadID, int laneIndex, SUMOReal pos)
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
int bestLaneOffset
The (signed) number of lanes to be crossed to get to the lane which allows to continue the drive...
Definition: MSVehicle.h:466
#define VAR_ROUTE
#define CMD_CHANGELANE
bool readTypeCheckingColor(tcpip::Storage &inputStorage, RGBColor &into)
Reads the value type and a color, verifying the type.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
#define VAR_SPEEDSETMODE
#define VAR_TAU
SUMOReal getSpeedWithoutTraciInfluence() const
Returns the uninfluenced velocity.
Definition: MSVehicle.cpp:2519
void setRespectJunctionPriority(bool value)
Sets whether junction priority rules shall be respected.
Definition: MSVehicle.cpp:327
#define CMD_STOP
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
SUMOReal getLength() const
Returns the lane's length.
Definition: MSLane.h:370
Position getPosition(const SUMOReal offset=0) const
Return current position (x/y, cartesian)
Definition: MSVehicle.cpp:603
SUMOReal departSpeed
(optional) The initial speed of the vehicle
The base class for an intersection.
Definition: MSJunction.h:61
#define VAR_ALLOWED_SPEED
#define TYPE_UBYTE
The position is given.
#define RTYPE_OK
#define POSITION_ROADMAP
unsigned int personCapacity
The vehicle's capacity (persons)
#define DISTANCE_REQUEST
Tag for the last element in the enum for safe int casting.
static bool getVariable(const int variable, const MSVehicleType &v, tcpip::Storage &tempMsg)
Processes a value request for the given type.
#define VAR_WAITING_TIME
virtual double readDouble()
SUMOReal arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
#define VAR_SIGNALS
#define VAR_TYPE
#define VAR_ROUTE_ID
Notification
Definition of a vehicle state.
virtual MSVehicle * removeVehicle(MSVehicle *remVehicle, MSMoveReminder::Notification notification, bool notify=true)
Definition: MSLane.cpp:1053
#define VAR_VEHICLECLASS
bool replaceRoute(const MSRoute *route, bool onInit=false, int offset=0)
Replaces the current route by the given one.
Definition: MSVehicle.cpp:457
#define VAR_SPEED_FACTOR
#define VAR_COLOR
SUMOReal getHCEmissions() const
Returns HC emission of the current state.
Definition: MSVehicle.cpp:2292
static bool getPosition(const std::string &id, Position &p)
Returns the named vehicle's position.
bool reached
Information whether the stop has been reached.
Definition: MSVehicle.h:584
bool readTypeCheckingInt(tcpip::Storage &inputStorage, int &into)
Reads the value type and an int, verifying the type.
SUMOReal arrivalPos
(optional) The position the vehicle shall arrive on
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:159
T MAX2(T a, T b)
Definition: StdDefs.h:74
const MSRoute & getRoute() const
Returns the current route.
Definition: MSBaseVehicle.h:82
unsigned int getPersonNumber() const
Returns the number of persons.
Definition: MSVehicle.cpp:2364
bool readTypeCheckingString(tcpip::Storage &inputStorage, std::string &into)
Reads the value type and a string, verifying the type.
#define TYPE_COLOR
#define TYPE_STRINGLIST
bool readTypeCheckingDouble(tcpip::Storage &inputStorage, double &into)
Reads the value type and a double, verifying the type.
bool hasDeparted() const
Returns whether this vehicle has already departed.
The vehicle got vaporized.
#define POSITION_3D
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary...
Definition: MSEdge.cpp:531
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
static std::pair< MSLane *, SUMOReal > convertCartesianToRoadMap(Position pos)
Definition of vehicle stop (position and duration)
Definition: MSVehicle.h:560
#define VAR_BEST_LANES
SUMOReal getCO2Emissions() const
Returns CO2 emission of the current state.
Definition: MSVehicle.cpp:2280
unsigned int personNumber
The number of persons in the vehicle.
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:79
std::pair< const MSVehicle *const, SUMOReal > getLeader(SUMOReal dist=0) const
Returns the leader of the vehicle looking for a fixed distance.
Definition: MSVehicle.cpp:2246
SUMOReal distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:229
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
SUMOReal getPositionOnLane() const
Get the vehicle's position along the lane.
Definition: MSVehicle.h:286
virtual void writeUnsignedByte(int)
const std::string & getParameter(const std::string &key, const std::string &defaultValue) const
Returns the value for a given key.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:235
EdgeBasicFunction
Defines possible edge types.
Definition: MSEdge.h:90
bool writeErrorStatusCmd(int commandId, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage with status = RTYPE_ERR.
Tag for the last element in the enum for safe int casting.
SUMOReal x() const
Returns the x-position.
Definition: Position.h:63
#define VAR_SPEED_DEVIATION
SUMOReal length
The overall length which may be driven when using this lane without a lane change.
Definition: MSVehicle.h:460
#define VAR_NOISEEMISSION
#define VAR_FUELCONSUMPTION
void addEffort(const MSEdge *const e, SUMOReal begin, SUMOReal end, SUMOReal value)
Adds an effort information for an edge and a time span.
static MSVehicleType * build(SUMOVTypeParameter &from)
Builds the microsim vehicle type described by the given parameter.
virtual void writeInt(int)
#define VAR_POSITION3D
The speed is given.
The car-following model and parameter.
Definition: MSVehicleType.h:74
#define TYPE_STRING
virtual int readUnsignedByte()
std::string toTaz
The vehicle's destination zone (district)
The lane is given.
void addTravelTime(const MSEdge *const e, SUMOReal begin, SUMOReal end, SUMOReal value)
Adds a travel time information for an edge and a time span.
static bool processGet(TraCIServer &server, tcpip::Storage &inputStorage, tcpip::Storage &outputStorage)
Processes a get value command (Command 0xa4: Get Vehicle Variable)
SUMOReal nextOccupation
As occupation, but without the first lane.
Definition: MSVehicle.h:464
#define VAR_NOXEMISSION
unsigned char blue() const
Returns the blue-amount of the color.
Definition: RGBColor.h:91
#define VAR_ANGLE
const std::string & getID() const
Returns the id.
Definition: Named.h:60
A road/street connecting two junctions.
Definition: MSEdge.h:81
MSLane * lane
The described lane.
Definition: MSVehicle.h:458
static bool vtdMap(const Position &pos, const std::string &origID, const SUMOReal angle, MSVehicle &v, TraCIServer &server, SUMOReal &bestDistance, MSLane **lane, SUMOReal &lanePos, int &routeOffset, ConstMSEdgeVector &edges)
#define VAR_PERSON_NUMBER
SUMOReal getLength() const
return the length of the edge
Definition: MSEdge.h:535
#define CMD_SLOWDOWN
MSLane * getLogicalPredecessorLane() const
Definition: MSLane.cpp:1357
#define VAR_SHAPECLASS
#define max(a, b)
Definition: polyfonts.c:65
void setEmergencyBrakeRedLight(bool value)
Sets whether red lights shall be a reason to brake.
Definition: MSVehicle.cpp:333
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
void removeEffort(const MSEdge *const e)
Removes the effort information for an edge.
#define REMOVE_ARRIVED
DepartLaneDefinition
Possible ways to choose a lane on depart.
#define VAR_ACCEL
#define CMD_CHANGETARGET
Representation of a vehicle.
Definition: SUMOVehicle.h:65
void setChosenSpeedFactor(const SUMOReal factor)
Returns the precomputed factor by which the driver wants to be faster than the speed limit...
virtual int readInt()
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
SUMOReal getDistanceBetween(SUMOReal fromPos, SUMOReal toPos, const MSEdge *fromEdge, const MSEdge *toEdge, bool includeInternal=true) const
Compute the distance between 2 given edges on this route, including the length of internal lanes...
Definition: MSRoute.cpp:255
#define REMOVE_TELEPORT_ARRIVED
void setLaneTimeLine(const std::vector< std::pair< SUMOTime, unsigned int > > &laneTimeLine)
Sets a new lane timeline.
Definition: MSVehicle.cpp:180
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
assigns new values
Definition: RGBColor.cpp:87
bool willPass(const MSEdge *const edge) const
Returns whether the vehicle wil pass the given edge.
Definition: MSVehicle.cpp:505
#define VAR_LANEPOSITION
A list of positions.
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:288
unsigned char alpha() const
Returns the alpha-amount of the color.
Definition: RGBColor.h:99
virtual void writeByte(int)
#define REMOVE_TELEPORT
const MSEdge * succEdge(unsigned int nSuccs) const
Returns the nSuccs'th successor of edge the vehicle is currently at.
ConstMSEdgeVector::const_iterator MSRouteIterator
Definition: MSRoute.h:61
bool readTypeCheckingStringList(tcpip::Storage &inputStorage, std::vector< std::string > &into)
Reads the value type and a string list, verifying the type.
SUMOReal z() const
Returns the z-position.
Definition: Position.h:73
The vehicle arrived at its destination (is deleted)
bool isStopped() const
Returns whether the vehicle is at a stop.
Definition: MSVehicle.cpp:807
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, const MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true)
Builds a vehicle, increases the number of built vehicles.
int arrivalLane
(optional) The lane the vehicle shall arrive on (not used yet)
virtual void writeStringList(const std::vector< std::string > &s)
SUMOTime depart
The vehicle's departure time.
#define VAR_PMXEMISSION
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
const ConstMSEdgeVector & getEdges() const
Definition: MSRoute.h:124
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
SUMOTime duration
The stopping duration.
Definition: MSVehicle.h:574
#define CMD_SET_VEHICLE_VARIABLE
T MIN2(T a, T b)
Definition: StdDefs.h:68
#define VAR_IMPERFECTION
std::string fromTaz
The vehicle's origin zone (district)
virtual std::string readString()
#define CMD_GET_EDGE_VARIABLE
Tag for the last element in the enum for safe int casting.
A structure representing the best lanes for continuing the route.
Definition: MSVehicle.h:456
#define VAR_EDGES
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MSVehicle.cpp:436
bool addTraciStop(MSLane *lane, SUMOReal pos, SUMOReal radius, SUMOTime duration, bool parking, bool triggered, bool containerTriggered, std::string &errorMsg)
Definition: MSVehicle.cpp:2432
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
#define VAR_EDGE_EFFORT
#define CMD_REROUTE_EFFORT
#define VAR_STOPSTATE
#define ADD
const ConstMSEdgeVector & getOutgoing() const
Definition: MSJunction.h:106
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:53
#define REMOVE
TraCI server used to control sumo by a remote TraCI client.
Definition: TraCIServer.h:74
const int VEHPARS_COLOR_SET
virtual void writeStorage(tcpip::Storage &store)
#define VAR_LEADER
bool isParking() const
Returns whether the vehicle is parking.
Definition: MSVehicle.cpp:813
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
Definition: MSVehicle.cpp:1896
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
bool allowsContinuation
Whether this lane allows to continue the drive.
Definition: MSVehicle.h:468
SUMOReal getHarmonoise_NoiseEmissions() const
Returns noise emissions of the current state.
Definition: MSVehicle.cpp:2316
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
std::string line
The vehicle's line (mainly for public transport)
#define INVALID_DOUBLE_VALUE
#define VAR_SPEED
DepartSpeedDefinition
Possible ways to choose the departure speed.
SUMOReal getNOxEmissions() const
Returns NOx emission of the current state.
Definition: MSVehicle.cpp:2298
void writeResponseWithLength(tcpip::Storage &outputStorage, tcpip::Storage &tempMsg)
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT(const MSEdgeVector &prohibited=MSEdgeVector()) const
Definition: MSNet.cpp:790
bool replaceRouteEdges(ConstMSEdgeVector &edges, bool onInit=false)
Replaces the current route by the given edges.
void setVTDControlled(MSVehicle *v, MSLane *l, SUMOReal pos, int edgeOffset, ConstMSEdgeVector route, SUMOTime t)
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, SUMOReal &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
SUMOReal getPMxEmissions() const
Returns PMx emission of the current state.
Definition: MSVehicle.cpp:2304
SUMOReal getCOEmissions() const
Returns CO emission of the current state.
Definition: MSVehicle.cpp:2286
#define VAR_EDGE_TRAVELTIME
SUMOReal rotationDegreeAtOffset(SUMOReal pos) const
Returns the rotation at the given length.
void push_back(const PositionVector &p)
Appends all positions from the given vector.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition: MSLane.cpp:852
#define VAR_COEMISSION
void setSpeedTimeLine(const std::vector< std::pair< SUMOTime, SUMOReal > > &speedTimeLine)
Sets a new velocity timeline.
Definition: MSVehicle.cpp:173
virtual void writeString(const std::string &s)
void removeTravelTime(const MSEdge *const e)
Removes the travel time information for an edge.
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
Definition: MSEdge.h:235
Influencer & getInfluencer()
Returns the velocity/lane influencer.
Definition: MSVehicle.cpp:2510
void scheduleVehicleRemoval(SUMOVehicle *veh)
Removes a vehicle after it has ended.
Structure representing possible vehicle parameter.
#define INVALID_INT_VALUE
MSRouteIterator end() const
Returns the end of the list of edges to pass.
Definition: MSRoute.cpp:81
#define VAR_MOVE_TO
#define SUMOTime_MAX
Definition: SUMOTime.h:44
#define TYPE_DOUBLE
void setConsiderMaxDeceleration(bool value)
Sets whether the maximum deceleration shall be regarded.
Definition: MSVehicle.cpp:321
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition: MSNet.h:329
int setParameter
Information for the router which parameter were set.
#define CMD_REROUTE_TRAVELTIME
std::vector< MSLane * > bestContinuations
Consecutive lane that can be followed without a lane change (contribute to length and occupation) ...
Definition: MSVehicle.h:470
#define TYPE_BYTE
SUMOReal y() const
Returns the y-position.
Definition: Position.h:68
SUMOReal getFuelConsumption() const
Returns fuel consumption of the current state.
Definition: MSVehicle.cpp:2310
static SUMOReal getMinAngleDiff(SUMOReal angle1, SUMOReal angle2)
Returns the minimum distance (clockwise/counter-clockwise) between both angles.
Definition: GeomHelper.cpp:405
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
Definition: MSBaseVehicle.h:90
void set(SUMOReal x, SUMOReal y)
Definition: Position.h:78
void setConsiderSafeVelocity(bool value)
Sets whether the safe velocity shall be regarded.
Definition: MSVehicle.cpp:309
MSRouteIterator edge
The edge in the route to stop at.
Definition: MSVehicle.h:562
SUMOReal getChosenSpeedFactor() const
Returns the precomputed factor by which the driver wants to be faster than the speed limit...
const std::string & getID() const
Returns the name of the vehicle type.
SUMOReal getSpeed() const
Returns the vehicle's current speed.
Definition: MSVehicle.h:294
int SUMOTime
Definition: SUMOTime.h:43
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
SUMOReal departPos
(optional) The position the vehicle shall depart from
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
void setLaneChangeMode(int value)
Sets lane changing behavior.
Definition: MSVehicle.cpp:339
SUMOReal getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
Definition: MSVehicle.h:370
virtual void writeDouble(double)
bool isStoppedTriggered() const
Returns whether the vehicle is on a triggered stop.
Definition: MSVehicle.cpp:819
#define REMOVE_VAPORIZED
unsigned size() const
Returns the number of edges to pass.
Definition: MSRoute.cpp:87
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:323
#define VAR_MOVE_TO_VTD
SUMOReal distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:240
const MSEdge * getRerouteOrigin() const
Returns the starting point for reroutes (usually the current edge)
Definition: MSVehicle.cpp:630
bool knowsEffort(const MSEdge *const e) const
Returns the information whether any effort is known for the given edge.
bool hasValidRoute(std::string &msg) const
Validates the current route.
int getSignals() const
Returns the signals.
Definition: MSVehicle.h:829
unsigned char green() const
Returns the green-amount of the color.
Definition: RGBColor.h:83
#define SUMOReal
Definition: config.h:218
void switchOffSignal(int signal)
Switches the given signal off.
Definition: MSVehicle.h:821
void switchOnSignal(int signal)
Switches the given signal on.
Definition: MSVehicle.h:813
virtual void compute(const E *from, const E *to, const V *const vehicle, SUMOTime msTime, std::vector< const E * > &into)=0
Builds the route between the given edges using the minimum effort at the given time The definition of...
void writeStatusCmd(int commandId, int status, const std::string &description, tcpip::Storage &outputStorage)
Writes a status command to the given storage.
const MSJunction * getFromJunction() const
Definition: MSEdge.h:345
#define VAR_SPEED_WITHOUT_TRACI
MSEdgeControl & getEdgeControl()
Returns the edge control.
Definition: MSNet.h:319
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
#define NUMERICAL_EPS
Definition: config.h:162
void reroute(SUMOTime t, SUMOAbstractRouter< MSEdge, SUMOVehicle > &router, const bool onInit=false, const bool withTaz=false)
Performs a rerouting using the given router.
#define VAR_LANECHANGE_MODE
#define VAR_MAXSPEED
#define DELTA_T
Definition: SUMOTime.h:50
bool retrieveExistingEffort(const MSEdge *const e, const SUMOReal t, SUMOReal &value) const
Returns an effort for an edge and time if stored.
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
The vehicle was teleported out of the net.
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
Definition: MSLane.cpp:1026
#define VAR_DECEL
#define VAR_ROUTE_VALID
The class responsible for building and deletion of vehicles.
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:78
#define VAR_PARAMETER
#define ID_COUNT
#define VAR_LANE_INDEX
bool knowsTravelTime(const MSEdge *const e) const
Returns the information whether any travel time is known for the given edge.
#define VAR_LANE_ID
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:354
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
Definition: MSVehicle.h:339
MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:331
The edge is an internal edge.
Definition: MSEdge.h:98
static const std::map< std::string, std::vector< MSLane * > > & getOrBuildVTDMap()
Tag for the last element in the enum for safe int casting.
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, MTRand *rng=0)
Returns the named vehicle type or a sample from the named distribution.
DepartPosDefinition
Possible ways to choose the departure position.
#define RTYPE_ERR
#define TYPE_INTEGER
#define VAR_MINGAP
#define ID_LIST
unsigned char red() const
Returns the red-amount of the color.
Definition: RGBColor.h:75
#define ADD_FULL
void add(SUMOVehicle *veh)
Adds a single vehicle for departure.
SUMOReal startPos
The stopping position start.
Definition: MSVehicle.h:570
Representation of a lane in the micro simulation.
Definition: MSLane.h:77
const MSEdgeWeightsStorage & getWeightsStorage() const
Returns the vehicle's internal edge travel times/efforts container.
Definition: MSVehicle.cpp:526
bool retrieveExistingTravelTime(const MSEdge *const e, const SUMOReal t, SUMOReal &value) const
Returns a travel time for an edge and time if stored.
unsigned int getRoutePosition() const
Definition: MSVehicle.cpp:511
static void parseEdgesList(const std::string &desc, ConstMSEdgeVector &into, const std::string &rid)
Parses the given string assuming it contains a list of edge ids divided by spaces.
Definition: MSEdge.cpp:594
virtual const std::string & getID() const =0
Get the vehicle's ID.
DepartDefinition
Possible ways to depart.
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error)
Validates a given depart value.
#define VAR_DISTANCE
bool readTypeCheckingByte(tcpip::Storage &inputStorage, int &into)
Reads the value type and a byte, verifying the type.
#define VAR_HCEMISSION
void setConsiderMaxAcceleration(bool value)
Sets whether the maximum acceleration shall be regarded.
Definition: MSVehicle.cpp:315
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:75
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
std::string id
The vehicle's id.
The vehicle is being teleported.
#define VAR_WIDTH
SUMOReal getAngle() const
Returns the vehicle's direction in degrees.
Definition: MSVehicle.cpp:646
const MSEdgeVector & getEdges() const
Returns loaded edges.
const std::string & getID() const
Returns the name of the vehicle.
virtual const MSVehicleType & getVehicleType() const =0
Returns the vehicle's type.
static bool dictionary(const std::string &id, const MSRoute *route)
Adds a route to the dictionary.
Definition: MSRoute.cpp:116
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.