void
NIVissimDistrictConnection::dict_BuildDistricts(NBDistrictCont& dc,
NBEdgeCont& ec,
NBNodeCont& nc/*,
NBDistribution &distc*/) {
// add the sources and sinks
// their normalised probability is computed within NBDistrict
// to avoid SUMOReal code writing and more securty within the converter
// go through the district table
for (std::map<int, std::vector<int> >::iterator k = myDistrictsConnections.begin(); k != myDistrictsConnections.end(); k++) {
// get the connections
const std::vector<int>& connections = (*k).second;
// retrieve the current district
NBDistrict* district =
dc.retrieve(toString<int>((*k).first));
NBNode* districtNode = nc.retrieve("District" + district->getID());
assert(district != 0 && districtNode != 0);
for (std::vector<int>::const_iterator l = connections.begin(); l != connections.end(); l++) {
NIVissimDistrictConnection* c = dictionary(*l);
// get the edge to connect the parking place to
NBEdge* e = ec.retrieve(toString<int>(c->myEdgeID));
if (e == 0) {
e = ec.retrievePossiblySplit(toString<int>(c->myEdgeID), c->myPosition);
}
if (e == 0) {
WRITE_WARNING("Could not build district '" + toString<int>((*k).first) + "' - edge '" + toString<int>(c->myEdgeID) + "' is missing.");
continue;
}
std::string id = "ParkingPlace" + toString<int>(*l);
NBNode* parkingPlace = nc.retrieve(id);
if (parkingPlace == 0) {
SUMOReal pos = c->getPosition();
if (pos < e->getLength() - pos) {
parkingPlace = e->getFromNode();
parkingPlace->invalidateIncomingConnections();
} else {
parkingPlace = e->getToNode();
parkingPlace->invalidateOutgoingConnections();
}
}
assert(
e->getToNode() == parkingPlace
||
e->getFromNode() == parkingPlace);
// build the connection to the source
if (e->getFromNode() == parkingPlace) {
id = "VissimFromParkingplace" + toString<int>((*k).first) + "-" + toString<int>(c->myID);
NBEdge* source =
new NBEdge(id, districtNode, parkingPlace,
"Connection", c->getMeanSpeed(/*distc*/) / (SUMOReal) 3.6, 3, -1,
NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET);
if (!ec.insert(source)) { // !!! in den Konstruktor
throw 1; // !!!
}
SUMOReal percNormed =
c->myPercentages[(*k).first];
if (!district->addSource(source, percNormed)) {
throw 1;
}
}
// build the connection to the destination
if (e->getToNode() == parkingPlace) {
id = "VissimToParkingplace" + toString<int>((*k).first) + "-" + toString<int>(c->myID);
NBEdge* destination =
new NBEdge(id, parkingPlace, districtNode,
"Connection", (SUMOReal) 100 / (SUMOReal) 3.6, 2, -1,
NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET);
if (!ec.insert(destination)) { // !!! (in den Konstruktor)
throw 1; // !!!
}
SUMOReal percNormed2 =
c->myPercentages[(*k).first];
if (!district->addSink(destination, percNormed2)) {
throw 1; // !!!
}
}
/*
if(e->getToNode()==districtNode) {
SUMOReal percNormed =
c->myPercentages[(*k).first];
district->addSink(e, percNormed);
}
if(e->getFromNode()==districtNode) {
SUMOReal percNormed =
c->myPercentages[(*k).first];
district->addSource(e, percNormed);
}
*/
}
/*
// add them as sources and sinks to the current district
for(std::vector<int>::const_iterator l=connections.begin(); l!=connections.end(); l++) {
// get the current connections
NIVissimDistrictConnection *c = dictionary(*l);
// get the edge to connect the parking place to
NBEdge *e = NBEdgeCont::retrieve(toString<int>(c->myEdgeID));
Position edgepos = c->geomPosition();
NBNode *edgeend = e->tryGetNodeAtPosition(c->myPosition,
e->getLength()/4.0);
if(edgeend==0) {
// Edge splitting omitted on build district connections by now
assert(false);
}
// build the district-node if not yet existing
std::string id = "VissimParkingplace" + district->getID();
NBNode *districtNode = nc.retrieve(id);
assert(districtNode!=0);
if(e->getToNode()==edgeend) {
// build the connection to the source
id = std::string("VissimFromParkingplace")
+ toString<int>((*k).first) + "-"
+ toString<int>(c->myID);
NBEdge *source =
new NBEdge(id, id, districtNode, edgeend,
"Connection", 100/3.6, 2, 100, 0,
NBEdge::EDGEFUNCTION_SOURCE);
NBEdgeCont::insert(source); // !!! (in den Konstruktor)
SUMOReal percNormed =
c->myPercentages[(*k).first];
district->addSource(source, percNormed);
} else {
// build the connection to the destination
id = std::string("VissimToParkingplace")
+ toString<int>((*k).first) + "-"
+ toString<int>(c->myID);
NBEdge *destination =
new NBEdge(id, id, edgeend, districtNode,
"Connection", 100/3.6, 2, 100, 0,
NBEdge::EDGEFUNCTION_SINK);
NBEdgeCont::insert(destination); // !!! (in den Konstruktor)
// add both the source and the sink to the district
SUMOReal percNormed =
c->myPercentages[(*k).first];
district->addSink(destination, percNormed);
}
}
*/
}
}
void
NIVissimEdge::buildNBEdge(NBDistrictCont& dc, NBNodeCont& nc, NBEdgeCont& ec,
SUMOReal sameNodesOffset) {
// build the edge
std::pair<NIVissimConnectionCluster*, NBNode*> fromInf, toInf;
NBNode* fromNode, *toNode;
fromNode = toNode = 0;
sort(myConnectionClusters.begin(), myConnectionClusters.end(), connection_cluster_position_sorter(myID));
sort(myDistrictConnections.begin(), myDistrictConnections.end());
ConnectionClusters tmpClusters = myConnectionClusters;
if (tmpClusters.size() != 0) {
sort(tmpClusters.begin(), tmpClusters.end(), connection_cluster_position_sorter(myID));
// get or build the from-node
// A node may have to be build when the edge starts or ends at
// a parking place or something like this
fromInf = getFromNode(nc, tmpClusters);
fromNode = fromInf.second;
// get or build the to-node
//if(tmpClusters.size()>0) {
toInf = getToNode(nc, tmpClusters);
toNode = toInf.second;
if (fromInf.first != 0 && toNode != 0 && fromInf.first->around(toNode->getPosition())) {
WRITE_WARNING("Will not build edge '" + toString(myID) + "'.");
myAmWithinJunction = true;
return;
}
//}
// if both nodes are the same, resolve the problem otherwise
if (fromNode == toNode) {
std::pair<NBNode*, NBNode*> tmp = resolveSameNode(nc, sameNodesOffset, fromNode, toNode);
if (fromNode != tmp.first) {
fromInf.first = 0;
}
if (toNode != tmp.second) {
toInf.first = 0;
}
fromNode = tmp.first;
toNode = tmp.second;
}
}
//
if (fromNode == 0) {
fromInf.first = 0;
Position pos = myGeom[0];
fromNode = new NBNode(toString<int>(myID) + "-SourceNode", pos, NODETYPE_NOJUNCTION);
if (!nc.insert(fromNode)) {
throw ProcessError("Could not insert node '" + fromNode->getID() + "' to nodes container.");
}
}
if (toNode == 0) {
toInf.first = 0;
Position pos = myGeom[-1];
toNode = new NBNode(toString<int>(myID) + "-DestinationNode", pos, NODETYPE_NOJUNCTION);
if (!nc.insert(toNode)) {
throw ProcessError("Could not insert node '" + toNode->getID() + "' to nodes container.");
}
}
// build the edge
SUMOReal avgSpeed = 0;
int i;
for (i = 0; i < (int) myNoLanes; i++) {
if (myLaneSpeeds.size() <= (size_t) i || myLaneSpeeds[i] == -1) {
myLanesWithMissingSpeeds.push_back(toString(myID) + "_" + toString(i));
avgSpeed += OptionsCont::getOptions().getFloat("vissim.default-speed");
} else {
avgSpeed += myLaneSpeeds[i];
}
}
avgSpeed /= (SUMOReal) myLaneSpeeds.size();
avgSpeed *= OptionsCont::getOptions().getFloat("vissim.speed-norm");
if (fromNode == toNode) {
WRITE_WARNING("Could not build edge '" + toString(myID) + "'; would connect same node.");
return;
}
NBEdge* buildEdge = new NBEdge(toString<int>(myID), fromNode, toNode, myType,
avgSpeed / (SUMOReal) 3.6, myNoLanes, -1,
NBEdge::UNSPECIFIED_WIDTH, NBEdge::UNSPECIFIED_OFFSET,
myGeom, myName, LANESPREAD_CENTER, true);
for (i = 0; i < (int) myNoLanes; i++) {
if ((int) myLaneSpeeds.size() <= i || myLaneSpeeds[i] == -1) {
buildEdge->setSpeed(i, OptionsCont::getOptions().getFloat("vissim.default-speed") / (SUMOReal) 3.6);
} else {
buildEdge->setSpeed(i, myLaneSpeeds[i] / (SUMOReal) 3.6);
}
}
ec.insert(buildEdge);
// check whether the edge contains any other clusters
if (tmpClusters.size() > 0) {
bool cont = true;
for (ConnectionClusters::iterator j = tmpClusters.begin(); cont && j != tmpClusters.end(); ++j) {
// split the edge at the previously build node
std::string nextID = buildEdge->getID() + "[1]";
cont = ec.splitAt(dc, buildEdge, (*j)->getNBNode());
// !!! what to do if the edge could not be split?
buildEdge = ec.retrieve(nextID);
}
}
}
void
NIImporter_OpenStreetMap::insertEdge(Edge* e, int index, NBNode* from, NBNode* to,
const std::vector<int> &passed, NBEdgeCont& ec, NBTypeCont& tc) {
// patch the id
std::string id = e->id;
if (index >= 0) {
id = id + "#" + toString(index);
}
// convert the shape
PositionVector shape;
for (std::vector<int>::const_iterator i = passed.begin(); i != passed.end(); ++i) {
NIOSMNode* n = myOSMNodes.find(*i)->second;
Position pos(n->lon, n->lat);
if (!NILoader::transformCoordinates(pos, true)) {
throw ProcessError("Unable to project coordinates for edge " + id + ".");
}
shape.push_back_noDoublePos(pos);
}
std::string type = e->myHighWayType;
if (!tc.knows(type)) {
if (type.find(compoundTypeSeparator) != std::string::npos) {
// this edge has a combination type which does not yet exist in the TypeContainer
StringTokenizer tok = StringTokenizer(type, compoundTypeSeparator);
std::set<std::string> types;
while (tok.hasNext()) {
std::string t = tok.next();
if (tc.knows(t)) {
types.insert(t);
} else {
WRITE_WARNING("Discarding edge " + id + " with type \"" + type + "\" (unknown compound \"" + t + "\").");
return;
}
}
if (types.size() == 2 &&
types.count("railway.tram") == 1) {
// compound types concern mostly the special case of tram tracks on a normal road.
// in this case we simply discard the tram information since the default for road is to allow all vclasses
types.erase("railway.tram");
std::string otherCompound = *(types.begin());
// XXX if otherCompound does not allow all vehicles (e.g. SVC_DELIVERY), tram will still not be allowed
type = otherCompound;
} else {
// other cases not implemented yet
WRITE_WARNING("Discarding edge " + id + " with unknown type \"" + type + "\".");
return;
}
} else {
// we do not know the type -> something else, ignore
//WRITE_WARNING("Discarding edge " + id + " with unknown type \"" + type + "\".");
return;
}
}
// otherwise it is not an edge and will be ignored
int noLanes = tc.getNumLanes(type);
SUMOReal speed = tc.getSpeed(type);
bool defaultsToOneWay = tc.getIsOneWay(type);
SUMOVehicleClasses allowedClasses = tc.getAllowedClasses(type);
SUMOVehicleClasses disallowedClasses = tc.getDisallowedClasses(type);
// check directions
bool addSecond = true;
if (e->myIsOneWay == "true" || e->myIsOneWay == "yes" || e->myIsOneWay == "1" || (defaultsToOneWay && e->myIsOneWay != "no" && e->myIsOneWay != "false" && e->myIsOneWay != "0")) {
addSecond = false;
}
// if we had been able to extract the number of lanes, override the highway type default
if (e->myNoLanes >= 0) {
if (!addSecond) {
noLanes = e->myNoLanes;
} else {
noLanes = e->myNoLanes / 2;
}
}
// if we had been able to extract the maximum speed, override the type's default
if (e->myMaxSpeed != MAXSPEED_UNGIVEN) {
speed = (SUMOReal)(e->myMaxSpeed / 3.6);
}
if (noLanes != 0 && speed != 0) {
if (e->myIsOneWay != "" && e->myIsOneWay != "false" && e->myIsOneWay != "no" && e->myIsOneWay != "true" && e->myIsOneWay != "yes" && e->myIsOneWay != "-1" && e->myIsOneWay != "1") {
WRITE_WARNING("New value for oneway found: " + e->myIsOneWay);
}
LaneSpreadFunction lsf = addSecond ? LANESPREAD_RIGHT : LANESPREAD_CENTER;
if (e->myIsOneWay != "-1") {
NBEdge* nbe = new NBEdge(id, from, to, type, speed, noLanes, tc.getPriority(type),
tc.getWidth(type), NBEdge::UNSPECIFIED_OFFSET, shape, e->streetName, lsf);
nbe->setVehicleClasses(allowedClasses, disallowedClasses);
if (!ec.insert(nbe)) {
delete nbe;
throw ProcessError("Could not add edge '" + id + "'.");
}
}
if (addSecond) {
if (e->myIsOneWay != "-1") {
id = "-" + id;
}
NBEdge* nbe = new NBEdge(id, to, from, type, speed, noLanes, tc.getPriority(type),
tc.getWidth(type), NBEdge::UNSPECIFIED_OFFSET, shape.reverse(), e->streetName, lsf);
nbe->setVehicleClasses(allowedClasses, disallowedClasses);
if (!ec.insert(nbe)) {
delete nbe;
throw ProcessError("Could not add edge '-" + id + "'.");
}
}
}
}