46#define FAR_AWAY 1000.0
62std::vector<std::string>
65 std::vector<std::string> ids;
68 ids.push_back(i->first);
82Person::getPosition(
const std::string& personID,
const bool includeZ) {
88Person::getPosition3D(
const std::string& personID) {
94Person::getAngle(
const std::string& personID) {
100Person::getSlope(
const std::string& personID) {
101 MSPerson* person = getPerson(personID);
103 const MSLane* lane = getSidewalk<MSEdge, MSLane>(person->
getEdge());
104 if (lane ==
nullptr) {
113Person::getSpeed(
const std::string& personID) {
114 return getPerson(personID)->getSpeed();
119Person::getRoadID(
const std::string& personID) {
120 return getPerson(personID)->getEdge()->getID();
125Person::getLaneID(
const std::string& personID) {
131Person::getLanePosition(
const std::string& personID) {
132 return getPerson(personID)->getEdgePos();
135std::vector<TraCIReservation>
136Person::getTaxiReservations(
int onlyNew) {
137 std::vector<TraCIReservation> result;
139 if (dispatcher !=
nullptr) {
141 if (traciDispatcher ==
nullptr) {
142 throw TraCIException(
"device.taxi.dispatch-algorithm 'traci' has not been loaded");
145 if (filterReservation(onlyNew, res, result)) {
152 if (includeRunning) {
154 filterReservation(onlyNew, res, result);
163Person::reservation_by_id_sorter::operator()(
const TraCIReservation& r1,
const TraCIReservation& r2)
const {
164 return r1.id < r2.id;
169Person::splitTaxiReservation(std::string reservationID,
const std::vector<std::string>& personIDs) {
171 if (dispatcher !=
nullptr) {
173 if (traciDispatcher !=
nullptr) {
177 throw TraCIException(
"device.taxi.dispatch-algorithm 'traci' has not been loaded");
181Person::filterReservation(
int onlyNew,
const Reservation* res, std::vector<libsumo::TraCIReservation>& reservations) {
182 if (onlyNew != 0 && (onlyNew & res->
state) == 0) {
185 std::vector<std::string> personIDs;
187 personIDs.push_back(p->getID());
189 std::sort(personIDs.begin(), personIDs.end());
190 reservations.push_back(TraCIReservation(res->
id,
206Person::getColor(
const std::string& personID) {
207 const RGBColor& col = getPerson(personID)->getParameter().color;
210 tcol.g = col.
green();
212 tcol.a = col.
alpha();
218Person::getTypeID(
const std::string& personID) {
219 return getPerson(personID)->getVehicleType().getID();
224Person::getWaitingTime(
const std::string& personID) {
225 return getPerson(personID)->getWaitingSeconds();
230Person::getNextEdge(
const std::string& personID) {
231 return getPerson(personID)->getNextEdge();
235std::vector<std::string>
236Person::getEdges(
const std::string& personID,
int nextStageIndex) {
239 throw TraCIException(
"The stage index must be lower than the number of remaining stages.");
242 throw TraCIException(
"The negative stage index must refer to a valid previous stage.");
244 std::vector<std::string> edgeIDs;
247 edgeIDs.push_back(e->getID());
255Person::getStage(
const std::string& personID,
int nextStageIndex) {
259 throw TraCIException(
"The stage index must be lower than the number of remaining stages.");
262 throw TraCIException(
"The negative stage index " +
toString(nextStageIndex) +
" must refer to a valid previous stage.");
270 result.edges.push_back(e->getID());
274 if (destinationStop !=
nullptr) {
275 result.destStop = destinationStop->
getID();
279 if (result.length == -1.) {
301 const std::set<std::string> lines = drivingStage->
getLines();
302 for (
auto line = lines.begin(); line != lines.end(); line++) {
303 if (line != lines.begin()) {
306 result.line += *line;
312 result.departPos = walkingStage->getDepartPos();
317 if (waitingStage->getPlannedDuration() > 0) {
318 result.travelTime =
STEPS2TIME(waitingStage->getPlannedDuration());
330Person::getRemainingStages(
const std::string& personID) {
331 return getPerson(personID)->getNumRemainingStages();
336Person::getVehicle(
const std::string& personID) {
337 const SUMOVehicle* veh = getPerson(personID)->getVehicle();
338 if (veh ==
nullptr) {
347Person::getParameter(
const std::string& personID,
const std::string& param) {
348 return getPerson(personID)->getParameter().getParameter(param,
"");
356Person::getEmissionClass(
const std::string& personID) {
362Person::getShapeClass(
const std::string& personID) {
368Person::getLength(
const std::string& personID) {
369 return getPerson(personID)->getVehicleType().getLength();
374Person::getSpeedFactor(
const std::string& personID) {
375 return getPerson(personID)->getChosenSpeedFactor();
380Person::getAccel(
const std::string& personID) {
381 return getPerson(personID)->getVehicleType().getCarFollowModel().getMaxAccel();
386Person::getDecel(
const std::string& personID) {
387 return getPerson(personID)->getVehicleType().getCarFollowModel().getMaxDecel();
391double Person::getEmergencyDecel(
const std::string& personID) {
392 return getPerson(personID)->getVehicleType().getCarFollowModel().getEmergencyDecel();
396double Person::getApparentDecel(
const std::string& personID) {
397 return getPerson(personID)->getVehicleType().getCarFollowModel().getApparentDecel();
401double Person::getActionStepLength(
const std::string& personID) {
402 return getPerson(personID)->getVehicleType().getActionStepLengthSecs();
407Person::getTau(
const std::string& personID) {
408 return getPerson(personID)->getVehicleType().getCarFollowModel().getHeadwayTime();
413Person::getImperfection(
const std::string& personID) {
414 return getPerson(personID)->getVehicleType().getCarFollowModel().getImperfection();
419Person::getSpeedDeviation(
const std::string& personID) {
420 return getPerson(personID)->getVehicleType().getSpeedFactor().getParameter()[1];
425Person::getVehicleClass(
const std::string& personID) {
426 return toString(getPerson(personID)->getVehicleType().getVehicleClass());
431Person::getMinGap(
const std::string& personID) {
432 return getPerson(personID)->getVehicleType().getMinGap();
437Person::getMinGapLat(
const std::string& personID) {
438 return getPerson(personID)->getVehicleType().getMinGapLat();
443Person::getMaxSpeed(
const std::string& personID) {
444 return getPerson(personID)->getMaxSpeed();
449Person::getMaxSpeedLat(
const std::string& personID) {
450 return getPerson(personID)->getVehicleType().getMaxSpeedLat();
455Person::getLateralAlignment(
const std::string& personID) {
456 return toString(getPerson(personID)->getVehicleType().getPreferredLateralAlignment());
461Person::getWidth(
const std::string& personID) {
462 return getPerson(personID)->getVehicleType().getWidth();
467Person::getHeight(
const std::string& personID) {
468 return getPerson(personID)->getVehicleType().getHeight();
473Person::getMass(
const std::string& personID) {
474 return getPerson(personID)->getVehicleType().getMass();
479Person::getPersonCapacity(
const std::string& personID) {
480 return getPerson(personID)->getVehicleType().getPersonCapacity();
485Person::getBoardingDuration(
const std::string& personID) {
486 return STEPS2TIME(getPerson(personID)->getVehicleType().getBoardingDuration(
true));
491Person::getImpatience(
const std::string& personID) {
492 return getPerson(personID)->getImpatience();
497Person::setSpeed(
const std::string& personID,
double speed) {
498 getPerson(personID)->setSpeed(speed);
503Person::setType(
const std::string& personID,
const std::string& typeID) {
505 if (vehicleType ==
nullptr) {
506 throw TraCIException(
"The vehicle type '" + typeID +
"' is not known.");
508 getPerson(personID)->replaceVehicleType(vehicleType);
513Person::add(
const std::string& personID,
const std::string& edgeID,
double pos,
double departInSecs,
const std::string typeID) {
516 p = getPerson(personID);
517 }
catch (TraCIException&) {
522 throw TraCIException(
"The person " + personID +
" to add already exists.");
527 vehicleParams.
id = personID;
531 throw TraCIException(
"Invalid type '" + typeID +
"' for person '" + personID +
"'");
536 throw TraCIException(
"Invalid edge '" + edgeID +
"' for person: '" + personID +
"'");
539 if (departInSecs < 0.) {
540 const int proc = (int) - departInSecs;
542 throw TraCIException(
"Invalid departure time." +
toString(depart) +
" " +
toString(proc));
548 WRITE_WARNINGF(
TL(
"Departure time=% for person '%' is in the past; using current time=% instead."),
551 vehicleParams.
depart = depart;
556 throw TraCIException(
"Invalid departure position.");
565 plan->push_back(
new MSStageWaiting(edge,
nullptr, 0, depart, pos,
"awaiting departure",
true));
573 throw TraCIException(e.what());
578Person::convertTraCIStage(
const TraCIStage& stage,
const std::string personID) {
580 if (!stage.destStop.empty()) {
583 throw TraCIException(
"Invalid stopping place id '" + stage.destStop +
"' for person: '" + personID +
"'");
586 switch (stage.type) {
588 if (stage.edges.empty()) {
589 throw TraCIException(
"The stage should have at least one edge");
591 std::string toId = stage.edges.back();
594 throw TraCIException(
"Invalid edge '" + toId +
"' for person: '" + personID +
"'");
601 if (stage.line.empty()) {
602 throw TraCIException(
"Empty lines parameter for person: '" + personID +
"'");
604 double arrivalPos = stage.arrivalPos;
621 throw TraCIException(e.what());
624 throw TraCIException(
"Empty edge list for walking stage of person '" + personID +
"'.");
626 double arrivalPos = stage.arrivalPos;
627 if (fabs(arrivalPos) > edges.back()->getLength()) {
628 throw TraCIException(
"Invalid arrivalPos for walking stage of person '" + personID +
"'.");
630 if (arrivalPos < 0) {
631 arrivalPos += edges.back()->getLength();
638 if (stage.travelTime < 0) {
639 throw TraCIException(
"Duration for person: '" + personID +
"' must not be negative");
650Person::appendStage(
const std::string& personID,
const TraCIStage& stage) {
652 MSStage* personStage = convertTraCIStage(stage, personID);
658Person::replaceStage(
const std::string& personID,
const int stageIndex,
const TraCIStage& stage) {
661 throw TraCIException(
"Specified stage index: is not valid for person " + personID);
663 MSStage* personStage = convertTraCIStage(stage, personID);
672Person::appendDrivingStage(
const std::string& personID,
const std::string& toEdge,
const std::string& lines,
const std::string& stopID) {
676 throw TraCIException(
"Invalid edge '" + toEdge +
"' for person: '" + personID +
"'");
678 if (lines.size() == 0) {
679 throw TraCIException(
"Empty lines parameter for person: '" + personID +
"'");
685 throw TraCIException(
"Invalid stopping place id '" + stopID +
"' for person: '" + personID +
"'");
693Person::appendWaitingStage(
const std::string& personID,
double duration,
const std::string& description,
const std::string& stopID) {
696 throw TraCIException(
"Duration for person: '" + personID +
"' must not be negative");
702 throw TraCIException(
"Invalid stopping place id '" + stopID +
"' for person: '" + personID +
"'");
710Person::appendWalkingStage(
const std::string& personID,
const std::vector<std::string>& edgeIDs,
double arrivalPos,
double duration,
double speed,
const std::string& stopID) {
716 throw TraCIException(e.what());
719 throw TraCIException(
"Empty edge list for walking stage of person '" + personID +
"'.");
721 if (fabs(arrivalPos) > edges.back()->getLength()) {
722 throw TraCIException(
"Invalid arrivalPos for walking stage of person '" + personID +
"'.");
724 if (arrivalPos < 0) {
725 arrivalPos += edges.back()->getLength();
731 throw TraCIException(
"Invalid stopping place id '" + stopID +
"' for person: '" + personID +
"'");
739Person::removeStage(
const std::string& personID,
int nextStageIndex) {
742 throw TraCIException(
"The stage index must be lower than the number of remaining stages.");
744 if (nextStageIndex < 0) {
745 throw TraCIException(
"The stage index may not be negative.");
752Person::rerouteTraveltime(
const std::string& personID) {
755 throw TraCIException(
"Person '" + personID +
"' has no remaining stages.");
765 throw TraCIException(
"Person '" + personID +
"' cannot reroute after the current stop.");
771 int nextIndex = firstIndex + 1;
783 if (newEdges.empty()) {
784 throw TraCIException(
"Could not find new route for person '" + personID +
"'.");
787 assert(!oldEdges.empty());
789 oldEdges.erase(oldEdges.begin());
792 if (newEdges == oldEdges && (firstIndex + 1 == nextIndex)) {
795 if (newEdges.front() != from) {
797 newEdges.insert(newEdges.begin(), from);
799 p->
replaceWalk(newEdges, departPos, firstIndex, nextIndex);
804Person::moveTo(
const std::string& personID,
const std::string& laneID,
double pos,
double posLat) {
808 throw TraCIException(
"Unknown lane '" + laneID +
"'.");
814 throw TraCIException(
"Invalid lateral position " +
toString(posLat) +
" on lane '" + laneID +
"'.");
824 throw TraCIException(
"Command moveTo is not supported for person '" + personID +
"' while " + p->
getCurrentStageDescription() +
".");
830Person::moveToXY(
const std::string& personID,
const std::string& edgeID,
const double x,
const double y,
double angle,
const int keepRoute,
double matchThreshold) {
832 const bool doKeepRoute = (keepRoute & 1) != 0;
833 const bool mayLeaveNetwork = (keepRoute & 2) != 0;
834 const bool ignorePermissions = (keepRoute & 4) != 0;
838 const double origAngle = angle;
843 while (angle >= 360.) {
853 std::cout <<
" want pos:" << pos <<
" edgeID:" << edgeID <<
" origAngle:" << origAngle <<
" angle:" << angle <<
" keepRoute:" << keepRoute << std::endl;
859 double lanePosLat = 0;
860 double bestDistance = std::numeric_limits<double>::max();
863 double maxRouteDistance = matchThreshold;
885 ev, routeIndex, vClass,
true,
886 bestDistance, &lane, lanePos, routeOffset);
890 speed, ev, routeIndex, currentLane, p->
getEdgePos(), currentLane !=
nullptr,
892 bestDistance, &lane, lanePos, routeOffset, edges);
893 if (edges.size() != 0 && ev.size() > 1) {
896 assert(lane !=
nullptr);
899 if (routeIndex == 0) {
906 if (origEdge->
getToJunction() == ev[routeIndex - 1]->getToJunction() || origEdge->
getToJunction() == ev[routeIndex - 1]->getFromJunction()) {
916 const MSEdge* newEdge = edges[0];
917 if (edges[0]->getFromJunction() == originalTarget || edges[0]->getToJunction() == originalTarget) {
919 edges[routeIndex] = newEdge;
923 if ((found && bestDistance <= maxRouteDistance) || mayLeaveNetwork) {
928 lanePosLat = perpDist;
929 if (!mayLeaveNetwork) {
941 lanePosLat = -lanePosLat;
949 assert((found && lane != 0) || (!found && lane == 0));
980 throw TraCIException(
"Command moveToXY is not supported for person '" + personID +
"' while " + p->
getCurrentStageDescription() +
".");
984 if (lane ==
nullptr) {
985 throw TraCIException(
"Could not map person '" + personID +
"' no road found within " +
toString(maxRouteDistance) +
"m.");
987 throw TraCIException(
"Could not map person '" + personID +
"' distance to road is " +
toString(bestDistance) +
".");
996Person::setParameter(
const std::string& personID,
const std::string& key,
const std::string& value) {
999 throw TraCIException(
"Person '" + personID +
"' does not support device parameters\n");
1001 throw TraCIException(
"Person '" + personID +
"' does not support laneChangeModel parameters\n");
1003 throw TraCIException(
"Person '" + personID +
"' does not support carFollowModel parameters\n");
1010 throw TraCIException(e.what());
1013 throw TraCIException(
"Person '" + personID +
"' does not support chanigng device status\n");
1021Person::setLength(
const std::string& personID,
double length) {
1022 getPerson(personID)->getSingularType().setLength(length);
1027Person::setMaxSpeed(
const std::string& personID,
double speed) {
1028 getPerson(personID)->getSingularType().setMaxSpeed(speed);
1033Person::setVehicleClass(
const std::string& personID,
const std::string& clazz) {
1039Person::setShapeClass(
const std::string& personID,
const std::string& clazz) {
1045Person::setEmissionClass(
const std::string& personID,
const std::string& clazz) {
1051Person::setWidth(
const std::string& personID,
double width) {
1052 getPerson(personID)->getSingularType().setWidth(width);
1057Person::setHeight(
const std::string& personID,
double height) {
1058 getPerson(personID)->getSingularType().setHeight(height);
1063Person::setMass(
const std::string& personID,
double mass) {
1064 getPerson(personID)->getSingularType().setMass(mass);
1069Person::setMinGap(
const std::string& personID,
double minGap) {
1070 getPerson(personID)->getSingularType().setMinGap(minGap);
1075Person::setAccel(
const std::string& personID,
double accel) {
1076 getPerson(personID)->getSingularType().setAccel(accel);
1081Person::setDecel(
const std::string& personID,
double decel) {
1082 getPerson(personID)->getSingularType().setDecel(decel);
1087Person::setEmergencyDecel(
const std::string& personID,
double decel) {
1088 getPerson(personID)->getSingularType().setEmergencyDecel(decel);
1093Person::setApparentDecel(
const std::string& personID,
double decel) {
1094 getPerson(personID)->getSingularType().setApparentDecel(decel);
1099Person::setImperfection(
const std::string& personID,
double imperfection) {
1100 getPerson(personID)->getSingularType().setImperfection(imperfection);
1105Person::setBoardingDuration(
const std::string& personID,
double boardingDuration) {
1111Person::setImpatience(
const std::string& personID,
double impatience) {
1118Person::setTau(
const std::string& personID,
double tau) {
1119 getPerson(personID)->getSingularType().setTau(tau);
1124Person::setMinGapLat(
const std::string& personID,
double minGapLat) {
1125 getPerson(personID)->getSingularType().setMinGapLat(minGapLat);
1130Person::setMaxSpeedLat(
const std::string& personID,
double speed) {
1131 getPerson(personID)->getSingularType().setMaxSpeedLat(speed);
1136Person::setLateralAlignment(
const std::string& personID,
const std::string& latAlignment) {
1140 getPerson(personID)->getSingularType().setPreferredLateralAlignment(lad, lao);
1142 throw TraCIException(
"Unknown value '" + latAlignment +
"' when setting latAlignment for person '" + personID +
"';\n must be one of (\"right\", \"center\", \"arbitrary\", \"nice\", \"compact\", \"left\" or a float)");
1148Person::setSpeedFactor(
const std::string& personID,
double factor) {
1149 getPerson(personID)->setChosenSpeedFactor(factor);
1154Person::setActionStepLength(
const std::string& personID,
double actionStepLength,
bool resetActionOffset) {
1159Person::remove(
const std::string& personID,
char ) {
1160 MSPerson* person = getPerson(personID);
1170Person::setColor(
const std::string& personID,
const TraCIColor& c) {
1172 p.
color.
set((
unsigned char)c.r, (
unsigned char)c.g, (
unsigned char)c.b, (
unsigned char)c.a);
1181Person::getPerson(
const std::string& personID) {
1188 shape.push_back(getPerson(
id)->getPosition());
1192std::shared_ptr<VariableWrapper>
1193Person::makeWrapper() {
1194 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
1199Person::handleVariable(
const std::string& objID,
const int variable, VariableWrapper* wrapper,
tcpip::Storage* paramData) {
1202 return wrapper->wrapStringList(objID, variable, getIDList());
1204 return wrapper->wrapInt(objID, variable, getIDCount());
1206 return wrapper->wrapPosition(objID, variable, getPosition(objID));
1208 return wrapper->wrapPosition(objID, variable, getPosition(objID,
true));
1210 return wrapper->wrapDouble(objID, variable, getAngle(objID));
1212 return wrapper->wrapDouble(objID, variable, getSlope(objID));
1214 return wrapper->wrapDouble(objID, variable, getSpeed(objID));
1216 return wrapper->wrapString(objID, variable, getRoadID(objID));
1218 return wrapper->wrapString(objID, variable, getLaneID(objID));
1220 return wrapper->wrapDouble(objID, variable, getLanePosition(objID));
1222 return wrapper->wrapColor(objID, variable, getColor(objID));
1224 return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
1226 return wrapper->wrapDouble(objID, variable, getImpatience(objID));
1228 return wrapper->wrapString(objID, variable, getTypeID(objID));
1230 return wrapper->wrapDouble(objID, variable, getSpeedFactor(objID));
1232 return wrapper->wrapString(objID, variable, getNextEdge(objID));
1234 return wrapper->wrapInt(objID, variable, getRemainingStages(objID));
1236 return wrapper->wrapString(objID, variable, getVehicle(objID));
1239 return wrapper->wrapDouble(objID, variable, getMaxSpeed(objID));
1242 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->
readString()));
1245 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->
readString()));
1250 return libsumo::VehicleType::handleVariable(getTypeID(objID), variable, wrapper, paramData);
std::vector< const MSEdge * > ConstMSEdgeVector
#define WRITE_WARNINGF(...)
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
LatAlignmentDefinition
Possible ways to choose the lateral alignment, i.e., how vehicles align themselves within their lane.
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
@ GIVEN
The position is given.
const long long int VEHPARS_COLOR_SET
DepartDefinition
Possible ways to depart.
@ DEF_MAX
Tag for the last element in the enum for safe int casting.
@ SUMO_TAG_BUS_STOP
A bus stop.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOM)
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
static const double INVALID_OFFSET
a value to signify offsets outside the range of [0, Line.length()]
static double naviDegree(const double angle)
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
static MSDispatch * getDispatchAlgorithm()
A dispatch algorithm that services customers in reservation order and always sends the closest availa...
std::string splitReservation(std::string resID, std::vector< std::string > personIDs)
split existing reservations and return the new reservation id
An algorithm that performs distpach for a taxi fleet.
std::vector< Reservation * > getReservations()
retrieve all reservations
virtual std::vector< const Reservation * > getRunningReservations()
retrieve all reservations that were already dispatched and are still active
A road/street connecting two junctions.
bool isWalkingArea() const
return whether this edge is walking area
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
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.
bool isNormal() const
return whether this edge is an internal edge
const MSJunction * getToJunction() const
double getLength() const
return the length of the edge
const MSJunction * getFromJunction() const
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....
static double gLateralResolution
The base class for an intersection.
Representation of a lane in the micro simulation.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
double interpolateLanePosToGeometryPos(double lanePos) const
virtual const PositionVector & getShape(bool) const
MSEdge & getEdge() const
Returns the lane's edge.
double getWidth() const
Returns the lane's width.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
MSPedestrianRouter & getPedestrianRouter(const int rngIndex, const MSEdgeVector &prohibited=MSEdgeVector()) const
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
MSStoppingPlace * getStoppingPlace(const std::string &id, const SumoXMLTag category) const
Returns the named stopping place of the given category.
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
virtual MSTransportableControl & getPersonControl()
Returns the person control.
static const double SIDEWALK_OFFSET
the offset for computing person positions when walking on edges without a sidewalk
static const double UNSPECIFIED_POS_LAT
the default lateral offset for persons when starting a walk
void replaceWalk(const ConstMSEdgeVector &newEdges, double departPos, int firstIndex, int nextIndex)
set new walk and replace the stages with relative indices in the interval [firstIndex,...
SUMOTime getIntendedDepart() const
std::string getIntendedVehicleID() const
const std::set< std::string > & getLines() const
std::string getVehicleType() const
virtual ConstMSEdgeVector getEdges() const
the edges of the current stage
virtual double getArrivalPos() const
SUMOTime getDeparted() const
get departure time of stage
virtual std::string getStageDescription(const bool isPerson) const =0
return (brief) string representation of the current stage
SUMOTime getArrived() const
get arrival time of stage
MSStoppingPlace * getDestinationStop() const
returns the destination stop (if any)
MSStageType getStageType() const
virtual double getDistance() const =0
get travel distance in this stage
ConstMSEdgeVector getEdges() const
the edges of the current stage
const std::vector< const MSEdge * > & getRoute() const
MSTransportableStateAdapter * getPState() const
const std::vector< constMSEdge * >::iterator getRouteStep() const
A lane area vehicles can halt at.
double getEndLanePosition() const
Returns the end position of this stop.
constVehIt loadedBegin() const
Returns the begin of the internal transportables map.
int size() const
Returns the number of known transportables.
constVehIt loadedEnd() const
Returns the end of the internal transportables map.
std::map< std::string, MSTransportable * >::const_iterator constVehIt
Definition of the internal transportables map iterator.
virtual MSTransportable * buildPerson(const SUMOVehicleParameter *pars, MSVehicleType *vtype, MSTransportable::MSTransportablePlan *plan, SumoRNG *rng) const
Builds a new person.
bool add(MSTransportable *transportable)
Adds a single transportable, returns false if an id clash occurred.
virtual double getEdgePos() const
Return the position on the edge.
SUMOVehicleClass getVClass() const
Returns the object's access class.
std::string getCurrentStageDescription() const
Returns the current stage description as a string.
const MSEdge * getArrivalEdge() const
returns the final arrival edge
MSStageType getStageType(int next) const
the stage type for the nth next stage
MSStage * getNextStage(int offset) const
Return the next (or previous) stage denoted by the offset.
void setJunctionModelParameter(const std::string &key, const std::string &value)
set individual junction model paramete (not type related)
int getNumRemainingStages() const
Return the number of remaining stages (including the current)
MSStage * getCurrentStage() const
Return the current stage.
void removeStage(int next, bool stayInSim=true)
removes the nth next stage
bool isPerson() const
Whether it is a person.
Position getPosition(const double) const
Return current position (x/y, cartesian)
double getArrivalPos() const
returns the final arrival pos
const MSVehicleType & getVehicleType() const
Returns the object's "vehicle" type.
int getNumStages() const
Return the total number stages in this person's plan.
MSStageType getCurrentStageType() const
the current stage type of the transportable
void appendStage(MSStage *stage, int next=-1)
Appends the given stage to the current plan.
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
const MSEdge * getEdge() const
Returns the current edge.
std::vector< MSStage * > MSTransportablePlan
the structure holding the plan of a transportable
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
double getMaxSpeed() const
Returns the maximum speed (the minimum of desired and physical maximum speed)
virtual void moveTo(MSPerson *p, MSLane *lane, double lanePos, double lanePosLat, SUMOTime t)
try to move transportable to the given position
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, SumoRNG *rng=nullptr, bool readOnly=false)
Returns the named vehicle type or a sample from the named distribution.
The car-following model and parameter.
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
void setBoardingDuration(SUMOTime duration, bool isPerson=true)
Set a new value for this type's boardingDuration.
void setImpatience(const double impatience)
Set a new value for this type's impatience.
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
const std::string & getID() const
Returns the id.
double compute(const E *from, const E *to, double departPos, double arrivalPos, double speed, SUMOTime msTime, const N *onlyNode, std::vector< const E * > &into, bool allEdges=false)
Builds the route between the given edges using the minimum effort at the given time The definition of...
C++ TraCI client API implementation.
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
A point in 2D or 3D with translation and scaling methods.
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position (in radians bet...
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
double distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector)
void move2side(double amount, double maxExtension=100)
move position vector to side using certain amount
double slopeDegreeAtOffset(double pos) const
Returns the slope at the given length.
unsigned char red() const
Returns the red-amount of the color.
unsigned char alpha() const
Returns the alpha-amount of the color.
unsigned char green() const
Returns the green-amount of the color.
unsigned char blue() const
Returns the blue-amount of the color.
void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
assigns new values
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
Representation of a vehicle.
Structure representing possible vehicle parameter.
long long int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
double departPos
(optional) The position the vehicle shall depart from
RGBColor color
The vehicle's color, TraCI may change this.
std::string id
The vehicle's id.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
static SUMOTime processActionStepLength(double given)
Checks and converts given value for the action step length from seconds to miliseconds assuring it be...
std::vector< std::string > getVector()
return vector of strings
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
static bool endsWith(const std::string &str, const std::string suffix)
Checks whether a given string ends with the suffix.
static TraCIPosition makeTraCIPosition(const Position &position, const bool includeZ=false)
static bool moveToXYMap_matchingRoutePosition(const Position &pos, const std::string &origID, const ConstMSEdgeVector ¤tRoute, int routeIndex, SUMOVehicleClass vClass, bool setLateralPos, double &bestDistance, MSLane **lane, double &lanePos, int &routeOffset)
static MSPerson * getPerson(const std::string &id)
static MSBaseVehicle * getVehicle(const std::string &id)
static void setRemoteControlled(MSVehicle *v, Position xyPos, MSLane *l, double pos, double posLat, double angle, int edgeOffset, ConstMSEdgeVector route, SUMOTime t)
static bool moveToXYMap(const Position &pos, double maxRouteDistance, bool mayLeaveNetwork, const std::string &origID, const double angle, double speed, const ConstMSEdgeVector ¤tRoute, const int routePosition, const MSLane *currentLane, double currentLanePos, bool onRoad, SUMOVehicleClass vClass, bool setLateralPos, double &bestDistance, MSLane **lane, double &lanePos, int &routeOffset, ConstMSEdgeVector &edges)
virtual std::string readString()
virtual int readUnsignedByte()
TRACI_CONST double INVALID_DOUBLE_VALUE
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_IMPATIENCE
TRACI_CONST int VAR_VEHICLE
TRACI_CONST int VAR_WAITING_TIME
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
TRACI_CONST int VAR_ROAD_ID
TRACI_CONST int VAR_TAXI_RESERVATIONS
TRACI_CONST int VAR_SPEED_FACTOR
TRACI_CONST int VAR_ANGLE
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_POSITION
TRACI_CONST int VAR_MAXSPEED
TRACI_CONST int STAGE_WAITING
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
TRACI_CONST int VAR_SLOPE
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int VAR_LANEPOSITION
TRACI_CONST int VAR_LANE_ID
TRACI_CONST int STAGE_WALKING
TRACI_CONST int VAR_POSITION3D
TRACI_CONST int VAR_SPEED
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_NEXT_EDGE
TRACI_CONST int STAGE_DRIVING
TRACI_CONST int VAR_STAGES_REMAINING
std::set< const MSTransportable * > persons