void
MSRouteHandler::openVehicleTypeDistribution(const SUMOSAXAttributes& attrs) {
bool ok = true;
myCurrentVTypeDistributionID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok);
if (ok) {
myCurrentVTypeDistribution = new RandomDistributor<MSVehicleType*>();
if (attrs.hasAttribute(SUMO_ATTR_VTYPES) || attrs.hasAttribute(SUMO_ATTR_VTYPES__DEPRECATED)) {
std::string vTypes;
if (!myHaveWarnedAboutDeprecatedVTypes && attrs.hasAttribute(SUMO_ATTR_VTYPES__DEPRECATED)) {
myHaveWarnedAboutDeprecatedVTypes = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_VTYPES__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_VTYPES) + "' instead.");
vTypes = attrs.getStringReporting(SUMO_ATTR_VTYPES__DEPRECATED, myCurrentVTypeDistributionID.c_str(), ok);
} else {
vTypes = attrs.getStringReporting(SUMO_ATTR_VTYPES, myCurrentVTypeDistributionID.c_str(), ok);
}
StringTokenizer st(vTypes);
while (st.hasNext()) {
std::string vtypeID = st.next();
MSVehicleType* type = MSNet::getInstance()->getVehicleControl().getVType(vtypeID);
if (type == 0) {
throw ProcessError("Unknown vtype '" + vtypeID + "' in distribution '" + myCurrentVTypeDistributionID + "'.");
}
myCurrentVTypeDistribution->add(type->getDefaultProbability(), type);
}
}
}
}
void
MSRouteHandler::myEndElement(int element) {
SUMORouteHandler::myEndElement(element);
switch (element) {
case SUMO_TAG_VTYPE: {
MSVehicleType* vehType = MSVehicleType::build(*myCurrentVType);
delete myCurrentVType;
myCurrentVType = 0;
if (!MSNet::getInstance()->getVehicleControl().addVType(vehType)) {
const std::string id = vehType->getID();
delete vehType;
if (!MSGlobals::gStateLoaded) {
throw ProcessError("Another vehicle type (or distribution) with the id '" + id + "' exists.");
}
} else {
if (myCurrentVTypeDistribution != 0) {
myCurrentVTypeDistribution->add(vehType->getDefaultProbability(), vehType);
}
}
}
break;
default:
break;
}
}
void
VehicleType::setEmergencyDecel(const std::string& typeID, double decel) {
MSVehicleType* v = getVType(typeID);
v->setEmergencyDecel(decel);
if (decel < v->getCarFollowModel().getMaxDecel()) {
WRITE_WARNING("New value of emergencyDecel (" + toString(decel) + ") is lower than decel (" + toString(v->getCarFollowModel().getMaxDecel()) + ")");
}
}
void
MSRouteHandler::myEndElement(SumoXMLTag element) throw(ProcessError) {
switch (element) {
case SUMO_TAG_ROUTE:
closeRoute();
break;
case SUMO_TAG_PERSON:
closePerson();
delete myVehicleParameter;
myVehicleParameter = 0;
break;
case SUMO_TAG_VEHICLE:
if (myVehicleParameter->repetitionNumber>0) {
myVehicleParameter->repetitionNumber++; // for backwards compatibility
// it is a flow, thus no break here
} else {
closeVehicle();
delete myVehicleParameter;
myVehicleParameter = 0;
break;
}
case SUMO_TAG_FLOW:
closeFlow();
break;
case SUMO_TAG_VTYPE_DISTRIBUTION:
closeVehicleTypeDistribution();
break;
case SUMO_TAG_ROUTE_DISTRIBUTION:
closeRouteDistribution();
break;
case SUMO_TAG_VTYPE: {
SUMOVehicleParserHelper::closeVTypeParsing(*myCurrentVType);
MSVehicleType *vehType = MSVehicleType::build(*myCurrentVType);
delete myCurrentVType;
myCurrentVType = 0;
if (!MSNet::getInstance()->getVehicleControl().addVType(vehType)) {
std::string id = vehType->getID();
delete vehType;
#ifdef HAVE_MESOSIM
if (!MSGlobals::gStateLoaded) {
#endif
throw ProcessError("Another vehicle type (or distribution) with the id '" + id + "' exists.");
#ifdef HAVE_MESOSIM
}
#endif
} else {
if (myCurrentVTypeDistribution != 0) {
myCurrentVTypeDistribution->add(vehType->getDefaultProbability(), vehType);
}
}
}
break;
default:
break;
}
}
void
VehicleType::setDecel(const std::string& typeID, double decel) {
MSVehicleType* v = getVType(typeID);
v->setDecel(decel);
// automatically raise emergencyDecel to ensure it is at least as high as decel
if (decel > v->getCarFollowModel().getEmergencyDecel()) {
if (v->getParameter().cfParameter.count(SUMO_ATTR_EMERGENCYDECEL) > 0) {
// notify user only if emergencyDecel was previously specified
WRITE_WARNING("Automatically setting emergencyDecel to " + toString(decel) + " for vType '" + typeID + "' to match decel.");
}
v->setEmergencyDecel(decel);
}
}
void
MSRouteHandler::openVehicleTypeDistribution(const SUMOSAXAttributes &attrs) {
if (attrs.setIDFromAttributes("vtypeDistribution", myCurrentVTypeDistributionID)) {
myCurrentVTypeDistribution = new RandomDistributor<MSVehicleType*>();
if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
bool ok = true;
StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_VTYPES, "vtypeDistribution", myCurrentVTypeDistributionID.c_str(), ok));
while (st.hasNext()) {
std::string vtypeID = st.next();
MSVehicleType *type = MSNet::getInstance()->getVehicleControl().getVType(vtypeID);
if (type==0) {
throw ProcessError("Unknown vtype '" + vtypeID + "' in distribution '" + myCurrentVTypeDistributionID + "'.");
}
myCurrentVTypeDistribution->add(type->getDefaultProbability(), type);
}
}
}
}
bool
TraCIServerAPI_VehicleType::getVariable(const int variable, const MSVehicleType& v, tcpip::Storage& tempMsg) {
switch (variable) {
case VAR_LENGTH:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getLength());
break;
case VAR_MINGAP:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getMinGap());
break;
case VAR_MAXSPEED:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getMaxSpeed());
break;
case VAR_ACCEL:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getCarFollowModel().getMaxAccel());
break;
case VAR_DECEL:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getCarFollowModel().getMaxDecel());
break;
case VAR_IMPERFECTION:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getCarFollowModel().getImperfection());
break;
case VAR_TAU:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getCarFollowModel().getHeadwayTime());
break;
case VAR_SPEED_FACTOR:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getSpeedFactor());
break;
case VAR_SPEED_DEVIATION:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getSpeedDeviation());
break;
case VAR_VEHICLECLASS:
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString(toString(v.getVehicleClass()));
break;
case VAR_EMISSIONCLASS:
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString(getVehicleEmissionTypeName(v.getEmissionClass()));
break;
case VAR_SHAPECLASS:
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString(getVehicleShapeName(v.getGuiShape()));
break;
case VAR_WIDTH:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v.getGuiWidth());
break;
case VAR_COLOR:
tempMsg.writeUnsignedByte(TYPE_COLOR);
tempMsg.writeUnsignedByte(static_cast<int>(v.getColor().red() * 255. + 0.5));
tempMsg.writeUnsignedByte(static_cast<int>(v.getColor().green() * 255. + 0.5));
tempMsg.writeUnsignedByte(static_cast<int>(v.getColor().blue() * 255. + 0.5));
tempMsg.writeUnsignedByte(255);
break;
default:
break;
}
return true;
}
bool
TraCIServerAPI_VehicleType::setVariable(const int cmd, const int variable, const int valueDataType,
MSVehicleType& v, traci::TraCIServer& server,
tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) {
switch (variable) {
case VAR_LENGTH: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting length requires a double.", outputStorage);
return false;
}
double val = inputStorage.readDouble();
if (val == 0.0 || fabs(val) == std::numeric_limits<double>::infinity()) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Invalid length.", outputStorage);
return false;
}
v.setLength(val);
}
break;
case VAR_MAXSPEED: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting maximum speed requires a double.", outputStorage);
return false;
}
double val = inputStorage.readDouble();
if (val == 0.0 || fabs(val) == std::numeric_limits<double>::infinity()) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Invalid maximum speed.", outputStorage);
return false;
}
v.setMaxSpeed(val);
}
break;
case VAR_VEHICLECLASS: {
if (valueDataType != TYPE_STRING) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting vehicle class requires a string.", outputStorage);
return false;
}
v.setVClass(getVehicleClassID(inputStorage.readString()));
}
break;
case VAR_SPEED_FACTOR: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting speed factor requires a double.", outputStorage);
return false;
}
v.setSpeedFactor(inputStorage.readDouble());
}
break;
case VAR_SPEED_DEVIATION: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting speed deviation requires a double.", outputStorage);
return false;
}
v.setSpeedDeviation(inputStorage.readDouble());
}
break;
case VAR_EMISSIONCLASS: {
if (valueDataType != TYPE_STRING) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting emission class requires a string.", outputStorage);
return false;
}
v.setEmissionClass(getVehicleEmissionTypeID(inputStorage.readString()));
}
break;
case VAR_WIDTH: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting width requires a double.", outputStorage);
return false;
}
v.setWidth(inputStorage.readDouble());
}
break;
case VAR_MINGAP: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting minimum gap requires a double.", outputStorage);
return false;
}
v.setMinGap(inputStorage.readDouble());
}
break;
case VAR_SHAPECLASS: {
if (valueDataType != TYPE_STRING) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting vehicle shape requires a string.", outputStorage);
return false;
}
v.setShape(getVehicleShapeID(inputStorage.readString()));
}
break;
case VAR_ACCEL: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting acceleration requires a double.", outputStorage);
return false;
}
v.getCarFollowModel().setMaxAccel(inputStorage.readDouble());
}
break;
case VAR_DECEL: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting deceleration requires a double.", outputStorage);
return false;
}
v.getCarFollowModel().setMaxDecel(inputStorage.readDouble());
}
break;
case VAR_IMPERFECTION: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting driver imperfection requires a double.", outputStorage);
return false;
}
v.getCarFollowModel().setImperfection(inputStorage.readDouble());
}
break;
case VAR_TAU: {
if (valueDataType != TYPE_DOUBLE) {
server.writeStatusCmd(cmd, RTYPE_ERR, "Setting headway time requires a double.", outputStorage);
return false;
}
v.getCarFollowModel().setHeadwayTime(inputStorage.readDouble());
}
break;
case VAR_COLOR: {
if (valueDataType != TYPE_COLOR) {
server.writeStatusCmd(cmd, RTYPE_ERR, "The color must be given using the according type.", outputStorage);
return false;
}
SUMOReal r = (SUMOReal) inputStorage.readUnsignedByte() / 255.;
SUMOReal g = (SUMOReal) inputStorage.readUnsignedByte() / 255.;
SUMOReal b = (SUMOReal) inputStorage.readUnsignedByte() / 255.;
inputStorage.readUnsignedByte(); // skip alpha level
RGBColor col(r, g, b);
v.setColor(col);
}
break;
default:
break;
}
return true;
}
bool
TraCIServerAPI_VehicleType::setVariable(const int cmd, const int variable,
MSVehicleType& v, traci::TraCIServer& server,
tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) {
switch (variable) {
case VAR_LENGTH: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting length requires a double.", outputStorage);
}
if (value == 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
return server.writeErrorStatusCmd(cmd, "Invalid length.", outputStorage);
}
v.setLength(value);
}
break;
case VAR_MAXSPEED: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting maximum speed requires a double.", outputStorage);
}
if (value == 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
return server.writeErrorStatusCmd(cmd, "Invalid maximum speed.", outputStorage);
}
v.setMaxSpeed(value);
}
break;
case VAR_VEHICLECLASS: {
std::string vclass;
if (!server.readTypeCheckingString(inputStorage, vclass)) {
return server.writeErrorStatusCmd(cmd, "Setting vehicle class requires a string.", outputStorage);
}
v.setVClass(getVehicleClassID(vclass));
}
break;
case VAR_SPEED_FACTOR: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting speed factor requires a double.", outputStorage);
}
v.setSpeedFactor(value);
}
break;
case VAR_SPEED_DEVIATION: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting speed deviation requires a double.", outputStorage);
}
v.setSpeedDeviation(value);
}
break;
case VAR_EMISSIONCLASS: {
std::string eclass;
if (!server.readTypeCheckingString(inputStorage, eclass)) {
return server.writeErrorStatusCmd(cmd, "Setting emission class requires a string.", outputStorage);
}
v.setEmissionClass(getVehicleEmissionTypeID(eclass));
}
break;
case VAR_WIDTH: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting width requires a double.", outputStorage);
}
v.setWidth(value);
}
break;
case VAR_MINGAP: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting minimum gap requires a double.", outputStorage);
}
v.setMinGap(value);
}
break;
case VAR_SHAPECLASS: {
std::string sclass;
if (!server.readTypeCheckingString(inputStorage, sclass)) {
return server.writeErrorStatusCmd(cmd, "Setting vehicle shape requires a string.", outputStorage);
}
v.setShape(getVehicleShapeID(sclass));
}
break;
case VAR_ACCEL: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting acceleration requires a double.", outputStorage);
}
v.getCarFollowModel().setMaxAccel(value);
}
break;
case VAR_DECEL: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting deceleration requires a double.", outputStorage);
}
v.getCarFollowModel().setMaxDecel(value);
}
break;
case VAR_IMPERFECTION: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting driver imperfection requires a double.", outputStorage);
}
v.getCarFollowModel().setImperfection(value);
}
break;
case VAR_TAU: {
double value = 0;
if (!server.readTypeCheckingDouble(inputStorage, value)) {
return server.writeErrorStatusCmd(cmd, "Setting headway time requires a double.", outputStorage);
}
v.getCarFollowModel().setHeadwayTime(value);
}
break;
case VAR_COLOR: {
RGBColor col;
if (!server.readTypeCheckingColor(inputStorage, col)) {
return server.writeErrorStatusCmd(cmd, "The color must be given using the according type.", outputStorage);
}
v.setColor(col);
}
break;
default:
break;
}
return true;
}
