void
GUINet::initGUIStructures() {
// initialise detector storage for gui
initDetectors();
// initialise the tl-map
initTLMap();
// initialise edge storage for gui
GUIEdge::fill(myEdgeWrapper);
// initialise junction storage for gui
size_t size = myJunctions->size();
myJunctionWrapper.reserve(size);
const std::map<std::string, MSJunction*> &junctions = myJunctions->getMyMap();
for (std::map<std::string, MSJunction*>::const_iterator i=junctions.begin(); i!=junctions.end(); ++i) {
myJunctionWrapper.push_back(new GUIJunctionWrapper(GUIGlObjectStorage::gIDStorage, *(*i).second));
}
// build the visualization tree
float *cmin = new float[2];
float *cmax = new float[2];
for (std::vector<GUIEdge*>::iterator i=myEdgeWrapper.begin(); i!=myEdgeWrapper.end(); ++i) {
GUIEdge *edge = *i;
Boundary b;
const std::vector<MSLane*> &lanes = edge->getLanes();
for (std::vector<MSLane*>::const_iterator j=lanes.begin(); j!=lanes.end(); ++j) {
b.add((*j)->getShape().getBoxBoundary());
}
b.grow(2.);
cmin[0] = b.xmin();
cmin[1] = b.ymin();
cmax[0] = b.xmax();
cmax[1] = b.ymax();
myGrid->Insert(cmin, cmax, edge);
myBoundary.add(b);
}
for (std::vector<GUIJunctionWrapper*>::iterator i=myJunctionWrapper.begin(); i!=myJunctionWrapper.end(); ++i) {
GUIJunctionWrapper *junction = *i;
Boundary b = junction->getBoundary();
b.grow(2.);
cmin[0] = b.xmin();
cmin[1] = b.ymin();
cmax[0] = b.xmax();
cmax[1] = b.ymax();
myGrid->Insert(cmin, cmax, junction);
myBoundary.add(b);
}
const std::vector<GUIGlObject_AbstractAdd*> &a = GUIGlObject_AbstractAdd::getObjectList();
for (std::vector<GUIGlObject_AbstractAdd*>::const_iterator i=a.begin(); i!=a.end(); ++i) {
GUIGlObject_AbstractAdd *o = *i;
Boundary b = o->getCenteringBoundary();
cmin[0] = b.xmin();
cmin[1] = b.ymin();
cmax[0] = b.xmax();
cmax[1] = b.ymax();
myGrid->Insert(cmin, cmax, o);
}
delete[] cmin;
delete[] cmax;
myGrid->add(myBoundary);
}
/* Test the method 'getBoxBoundary'*/
TEST_F(PositionVectorTest, test_method_getBoxBoundary) {
Boundary bound = vectorPolygon->getBoxBoundary();
EXPECT_DOUBLE_EQ(bound.xmax(), 4);
EXPECT_DOUBLE_EQ(bound.xmin(), 0);
EXPECT_DOUBLE_EQ(bound.ymax(), 4);
EXPECT_DOUBLE_EQ(bound.ymin(), 0);
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_GUI::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
// variable & id
int variable = inputStorage.readUnsignedByte();
std::string id = inputStorage.readString();
// check variable
if (variable != ID_LIST && variable != VAR_VIEW_ZOOM && variable != VAR_VIEW_OFFSET
&& variable != VAR_VIEW_SCHEMA && variable != VAR_VIEW_BOUNDARY) {
return server.writeErrorStatusCmd(CMD_GET_GUI_VARIABLE, "Get GUI Variable: unsupported variable specified", outputStorage);
}
// begin response building
tcpip::Storage tempMsg;
// response-code, variableID, objectID
tempMsg.writeUnsignedByte(RESPONSE_GET_GUI_VARIABLE);
tempMsg.writeUnsignedByte(variable);
tempMsg.writeString(id);
// process request
if (variable == ID_LIST) {
std::vector<std::string> ids = getMainWindow()->getViewIDs();
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(ids);
} else {
GUISUMOAbstractView* v = getNamedView(id);
if (v == 0) {
return server.writeErrorStatusCmd(CMD_GET_GUI_VARIABLE, "View '" + id + "' is not known", outputStorage);
}
switch (variable) {
case VAR_VIEW_ZOOM:
tempMsg.writeUnsignedByte(TYPE_DOUBLE);
tempMsg.writeDouble(v->getChanger().getZoom());
break;
case VAR_VIEW_OFFSET:
tempMsg.writeUnsignedByte(POSITION_2D);
tempMsg.writeDouble(v->getChanger().getXPos());
tempMsg.writeDouble(v->getChanger().getYPos());
break;
case VAR_VIEW_SCHEMA: {
FXComboBox& c = v->getColoringSchemesCombo();
tempMsg.writeUnsignedByte(TYPE_STRING);
tempMsg.writeString((std::string)c.getItem(c.getCurrentItem()).text());
break;
}
case VAR_VIEW_BOUNDARY: {
tempMsg.writeUnsignedByte(TYPE_BOUNDINGBOX);
Boundary b = v->getVisibleBoundary();
tempMsg.writeDouble(b.xmin());
tempMsg.writeDouble(b.ymin());
tempMsg.writeDouble(b.xmax());
tempMsg.writeDouble(b.ymax());
break;
}
default:
break;
}
}
server.writeStatusCmd(CMD_GET_GUI_VARIABLE, RTYPE_OK, "", outputStorage);
server.writeResponseWithLength(outputStorage, tempMsg);
return true;
}
void BinaryFormatter::writeAttr(std::ostream& into, const SumoXMLAttr attr, const Boundary& val) {
BinaryFormatter::writeAttrHeader(into, attr, BF_BOUNDARY);
FileHelpers::writeFloat(into, val.xmin());
FileHelpers::writeFloat(into, val.ymin());
FileHelpers::writeFloat(into, val.xmax());
FileHelpers::writeFloat(into, val.ymax());
}
/* Test the method 'add'*/
TEST(Boundary, test_method_add) {
Boundary *bound = new Boundary();
bound->add(1,2);
EXPECT_DOUBLE_EQ(bound->xmax(), 1);
EXPECT_DOUBLE_EQ(bound->xmin(), 1);
EXPECT_DOUBLE_EQ(bound->ymax(), 2);
EXPECT_DOUBLE_EQ(bound->ymin(), 2);
}
/* Test the method 'add'*/
TEST(Boundary, test_method_add) {
Boundary bound;
bound.add(1,2);
EXPECT_DOUBLE_EQ(bound.xmax(), 1);
EXPECT_DOUBLE_EQ(bound.xmin(), 1);
EXPECT_DOUBLE_EQ(bound.ymax(), 2);
EXPECT_DOUBLE_EQ(bound.ymin(), 2);
}
/* Test the method 'flipY'*/
TEST(Boundary, test_method_flipY) {
Boundary *bound = new Boundary(1,2,3,6);
bound->flipY();
EXPECT_DOUBLE_EQ(bound->xmax(), 3);
EXPECT_DOUBLE_EQ(bound->xmin(), 1);
EXPECT_DOUBLE_EQ(bound->ymax(), -2);
EXPECT_DOUBLE_EQ(bound->ymin(), -6);
}
/* Test the method 'moveby'*/
TEST(Boundary, test_method_moveby) {
Boundary *bound = new Boundary(1,2,3,6);
bound->moveby(2.5,-3.5);
EXPECT_DOUBLE_EQ(bound->xmax(), 5.5);
EXPECT_DOUBLE_EQ(bound->xmin(), 3.5);
EXPECT_DOUBLE_EQ(bound->ymax(), 2.5);
EXPECT_DOUBLE_EQ(bound->ymin(), -1.5);
}
void
NBHeightMapper::addTriangle(PositionVector corners) {
Triangle* triangle = new Triangle(corners);
myTriangles.push_back(triangle);
Boundary b = corners.getBoxBoundary();
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
myRTree.Insert(cmin, cmax, triangle);
}
/* Test the method 'add' with multiple calls*/
TEST(Boundary, test_method_add_multiple) {
Boundary *bound = new Boundary();
bound->add(-1,-2);
bound->add(3,5);
bound->add(5,8);
EXPECT_DOUBLE_EQ(bound->xmax(), 5);
EXPECT_DOUBLE_EQ(bound->xmin(), -1);
EXPECT_DOUBLE_EQ(bound->ymax(), 8);
EXPECT_DOUBLE_EQ(bound->ymin(), -2);
}
/* Test the method 'add' with multiple calls*/
TEST(Boundary, test_method_add_multiple) {
Boundary bound;
bound.add(-1,-2);
bound.add(3,5);
bound.add(5,8);
EXPECT_DOUBLE_EQ(bound.xmax(), 5);
EXPECT_DOUBLE_EQ(bound.xmin(), -1);
EXPECT_DOUBLE_EQ(bound.ymax(), 8);
EXPECT_DOUBLE_EQ(bound.ymin(), -2);
}
NamedRTree*
TraCIServerAPI_Junction::getTree() {
NamedRTree* t = new NamedRTree();
const std::map<std::string, MSJunction*>& junctions = MSNet::getInstance()->getJunctionControl().getMyMap();
for (std::map<std::string, MSJunction*>::const_iterator i = junctions.begin(); i != junctions.end(); ++i) {
Boundary b = (*i).second->getShape().getBoxBoundary();
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
t->Insert(cmin, cmax, (*i).second);
}
return t;
}
int
GUIViewTraffic::doPaintGL(int mode, const Boundary& bound) {
// init view settings
glRenderMode(mode);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// draw decals (if not in grabbing mode)
if (!myUseToolTips) {
drawDecals();
if (myVisualizationSettings->showGrid) {
paintGLGrid();
}
}
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
float minB[2];
float maxB[2];
minB[0] = bound.xmin();
minB[1] = bound.ymin();
maxB[0] = bound.xmax();
maxB[1] = bound.ymax();
myVisualizationSettings->scale = m2p(SUMO_const_laneWidth);
glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_POLYGON_OFFSET_LINE);
int hits2 = myGrid->Search(minB, maxB, *myVisualizationSettings);
//
if (myAdditionallyDrawn.size() > 0) {
glTranslated(0, 0, -.01);
GUINet::getGUIInstance()->lock();
for (std::map<GUIGlObject*, int>::iterator i = myAdditionallyDrawn.begin(); i != myAdditionallyDrawn.end(); ++i) {
(i->first)->drawGLAdditional(this, *myVisualizationSettings);
}
GUINet::getGUIInstance()->unlock();
glTranslated(0, 0, .01);
}
glPopMatrix();
/*
// draw legends
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslated(1.-.2, 1.-.5, 0.);
glScaled(.2, .5, 1.);
GUIColoringSchemesMap<GUILane> &sm = GUIViewTraffic::getLaneSchemesMap(); //!!!
sm.getColorer(myVisualizationSettings->laneEdgeMode)->drawLegend();
*/
return hits2;
}
void
TraCIServer::collectObjectsInRange(int domain, const PositionVector& shape, SUMOReal range, std::set<std::string>& into) {
// build the look-up tree if not yet existing
if (myObjects.find(domain) == myObjects.end()) {
switch (domain) {
case CMD_GET_INDUCTIONLOOP_VARIABLE:
myObjects[CMD_GET_INDUCTIONLOOP_VARIABLE] = TraCIServerAPI_InductionLoop::getTree();
break;
case CMD_GET_EDGE_VARIABLE:
case CMD_GET_LANE_VARIABLE:
case CMD_GET_VEHICLE_VARIABLE:
myObjects[CMD_GET_EDGE_VARIABLE] = 0;
myObjects[CMD_GET_LANE_VARIABLE] = 0;
myObjects[CMD_GET_VEHICLE_VARIABLE] = 0;
myLaneTree = new RTree<MSLane*, MSLane, float, 2, TraCIServerAPI_Lane::StoringVisitor>(&MSLane::visit);
MSLane::fill(*myLaneTree);
break;
case CMD_GET_POI_VARIABLE:
myObjects[CMD_GET_POI_VARIABLE] = TraCIServerAPI_POI::getTree();
break;
case CMD_GET_POLYGON_VARIABLE:
myObjects[CMD_GET_POLYGON_VARIABLE] = TraCIServerAPI_Polygon::getTree();
break;
case CMD_GET_JUNCTION_VARIABLE:
myObjects[CMD_GET_JUNCTION_VARIABLE] = TraCIServerAPI_Junction::getTree();
break;
default:
break;
}
}
const Boundary b = shape.getBoxBoundary().grow(range);
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
switch (domain) {
case CMD_GET_INDUCTIONLOOP_VARIABLE:
case CMD_GET_POI_VARIABLE:
case CMD_GET_POLYGON_VARIABLE:
case CMD_GET_JUNCTION_VARIABLE: {
Named::StoringVisitor sv(into);
myObjects[domain]->Search(cmin, cmax, sv);
}
break;
case CMD_GET_EDGE_VARIABLE:
case CMD_GET_LANE_VARIABLE:
case CMD_GET_VEHICLE_VARIABLE: {
TraCIServerAPI_Lane::StoringVisitor sv(into, shape, range, domain);
myLaneTree->Search(cmin, cmax, sv);
}
break;
default:
break;
}
}
NamedRTree*
TraCIServerAPI_Polygon::getTree() {
NamedRTree* t = new NamedRTree();
ShapeContainer& shapeCont = MSNet::getInstance()->getShapeContainer();
const std::map<std::string, Polygon*>& polygons = shapeCont.getPolygons().getMyMap();
for (std::map<std::string, Polygon*>::const_iterator i = polygons.begin(); i != polygons.end(); ++i) {
Boundary b = (*i).second->getShape().getBoxBoundary();
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
t->Insert(cmin, cmax, (*i).second);
}
return t;
}
Position
GeomHelper::crossPoint(const Boundary& b, const PositionVector& v) {
if (v.intersects(Position(b.xmin(), b.ymin()), Position(b.xmin(), b.ymax()))) {
return v.intersectsAtPoint(
Position(b.xmin(), b.ymin()),
Position(b.xmin(), b.ymax()));
}
if (v.intersects(Position(b.xmax(), b.ymin()), Position(b.xmax(), b.ymax()))) {
return v.intersectsAtPoint(
Position(b.xmax(), b.ymin()),
Position(b.xmax(), b.ymax()));
}
if (v.intersects(Position(b.xmin(), b.ymin()), Position(b.xmax(), b.ymin()))) {
return v.intersectsAtPoint(
Position(b.xmin(), b.ymin()),
Position(b.xmax(), b.ymin()));
}
if (v.intersects(Position(b.xmin(), b.ymax()), Position(b.xmax(), b.ymax()))) {
return v.intersectsAtPoint(
Position(b.xmin(), b.ymax()),
Position(b.xmax(), b.ymax()));
}
throw 1;
}
// ===========================================================================
// method definitions
// ===========================================================================
bool
TraCIServerAPI_Simulation::processGet(TraCIServer& server, tcpip::Storage& inputStorage,
tcpip::Storage& outputStorage) {
// variable & id
int variable = inputStorage.readUnsignedByte();
std::string id = inputStorage.readString();
// check variable
if (variable != VAR_TIME_STEP
&& variable != VAR_LOADED_VEHICLES_NUMBER && variable != VAR_LOADED_VEHICLES_IDS
&& variable != VAR_DEPARTED_VEHICLES_NUMBER && variable != VAR_DEPARTED_VEHICLES_IDS
&& variable != VAR_TELEPORT_STARTING_VEHICLES_NUMBER && variable != VAR_TELEPORT_STARTING_VEHICLES_IDS
&& variable != VAR_TELEPORT_ENDING_VEHICLES_NUMBER && variable != VAR_TELEPORT_ENDING_VEHICLES_IDS
&& variable != VAR_ARRIVED_VEHICLES_NUMBER && variable != VAR_ARRIVED_VEHICLES_IDS
&& variable != VAR_DELTA_T && variable != VAR_NET_BOUNDING_BOX
&& variable != VAR_MIN_EXPECTED_VEHICLES
&& variable != POSITION_CONVERSION && variable != DISTANCE_REQUEST
&& variable != VAR_BUS_STOP_WAITING
&& variable != VAR_PARKING_STARTING_VEHICLES_NUMBER && variable != VAR_PARKING_STARTING_VEHICLES_IDS
&& variable != VAR_PARKING_ENDING_VEHICLES_NUMBER && variable != VAR_PARKING_ENDING_VEHICLES_IDS
&& variable != VAR_STOP_STARTING_VEHICLES_NUMBER && variable != VAR_STOP_STARTING_VEHICLES_IDS
&& variable != VAR_STOP_ENDING_VEHICLES_NUMBER && variable != VAR_STOP_ENDING_VEHICLES_IDS
) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Get Simulation Variable: unsupported variable specified", outputStorage);
}
// begin response building
tcpip::Storage tempMsg;
// response-code, variableID, objectID
tempMsg.writeUnsignedByte(RESPONSE_GET_SIM_VARIABLE);
tempMsg.writeUnsignedByte(variable);
tempMsg.writeString(id);
// process request
switch (variable) {
case VAR_TIME_STEP:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt(MSNet::getInstance()->getCurrentTimeStep());
break;
case VAR_LOADED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_BUILT);
break;
case VAR_LOADED_VEHICLES_IDS: {
const std::vector<std::string>& ids = server.getVehicleStateChanges().find(MSNet::VEHICLE_STATE_BUILT)->second;
tempMsg.writeUnsignedByte(TYPE_STRINGLIST);
tempMsg.writeStringList(ids);
}
break;
case VAR_DEPARTED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_DEPARTED);
break;
case VAR_DEPARTED_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_DEPARTED);
break;
case VAR_TELEPORT_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_TELEPORT);
break;
case VAR_TELEPORT_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_TELEPORT);
break;
case VAR_TELEPORT_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_TELEPORT);
break;
case VAR_TELEPORT_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_TELEPORT);
break;
case VAR_ARRIVED_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ARRIVED);
break;
case VAR_ARRIVED_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ARRIVED);
break;
case VAR_PARKING_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_PARKING);
break;
case VAR_PARKING_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_PARKING);
break;
case VAR_PARKING_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_PARKING);
break;
case VAR_PARKING_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_PARKING);
break;
case VAR_STOP_STARTING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_STOP);
break;
case VAR_STOP_STARTING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_STARTING_STOP);
break;
case VAR_STOP_ENDING_VEHICLES_NUMBER:
writeVehicleStateNumber(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_STOP);
break;
case VAR_STOP_ENDING_VEHICLES_IDS:
writeVehicleStateIDs(server, tempMsg, MSNet::VEHICLE_STATE_ENDING_STOP);
break;
case VAR_DELTA_T:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt(DELTA_T);
break;
case VAR_NET_BOUNDING_BOX: {
tempMsg.writeUnsignedByte(TYPE_BOUNDINGBOX);
Boundary b = GeoConvHelper::getFinal().getConvBoundary();
tempMsg.writeDouble(b.xmin());
tempMsg.writeDouble(b.ymin());
tempMsg.writeDouble(b.xmax());
tempMsg.writeDouble(b.ymax());
break;
}
break;
case VAR_MIN_EXPECTED_VEHICLES:
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt(MSNet::getInstance()->getVehicleControl().getActiveVehicleCount() + MSNet::getInstance()->getInsertionControl().getPendingFlowCount());
break;
case POSITION_CONVERSION:
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 2) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Position conversion requires a source position and a position type as parameter.", outputStorage);
}
if (!commandPositionConversion(server, inputStorage, tempMsg, CMD_GET_SIM_VARIABLE)) {
return false;
}
break;
case DISTANCE_REQUEST:
if (inputStorage.readUnsignedByte() != TYPE_COMPOUND) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires a compound object.", outputStorage);
}
if (inputStorage.readInt() != 3) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of distance requires two positions and a distance type as parameter.", outputStorage);
}
if (!commandDistanceRequest(server, inputStorage, tempMsg, CMD_GET_SIM_VARIABLE)) {
return false;
}
break;
case VAR_BUS_STOP_WAITING: {
std::string id;
if (!server.readTypeCheckingString(inputStorage, id)) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Retrieval of persons at busstop requires a string.", outputStorage);
}
MSBusStop* s = MSNet::getInstance()->getBusStop(id);
if (s == 0) {
return server.writeErrorStatusCmd(CMD_GET_SIM_VARIABLE, "Unknown bus stop '" + id + "'.", outputStorage);
}
tempMsg.writeUnsignedByte(TYPE_INTEGER);
tempMsg.writeInt(s->getPersonNumber());
break;
}
default:
break;
}
server.writeStatusCmd(CMD_GET_SIM_VARIABLE, RTYPE_OK, "", outputStorage);
server.writeResponseWithLength(outputStorage, tempMsg);
return true;
}
int
main(int argc, char **argv) {
OptionsCont &oc = OptionsCont::getOptions();
oc.setApplicationDescription("Importer of polygons and POIs for the road traffic simulation SUMO.");
oc.setApplicationName("polyconvert", "SUMO polyconvert Version " + (std::string)VERSION_STRING);
int ret = 0;
try {
// initialise subsystems
XMLSubSys::init(false);
fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
MsgHandler::initOutputOptions();
// build the projection
Boundary origNetBoundary, pruningBoundary;
Position2D netOffset;
std::string proj;
PCNetProjectionLoader::loadIfSet(oc, netOffset, origNetBoundary, pruningBoundary, proj);
if (proj != "") {
if (oc.isDefault("proj")) {
oc.set("proj", proj);
}
if (oc.isDefault("x-offset-to-apply")) {
oc.set("x-offset-to-apply", toString(netOffset.x()));
}
if (oc.isDefault("y-offset-to-apply")) {
oc.set("y-offset-to-apply", toString(netOffset.y()));
}
}
#ifdef HAVE_PROJ
unsigned numProjections = oc.getBool("proj.simple") + oc.getBool("proj.utm") + oc.getBool("proj.dhdn") + (oc.getString("proj").length() > 1);
if ((oc.isSet("osm-files") || oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && numProjections == 0) {
oc.set("proj.utm", true);
}
if ((oc.isSet("dlr-navteq-poly-files") || oc.isSet("dlr-navteq-poi-files")) && oc.isDefault("proj.shift")) {
oc.set("proj.shift", std::string("5"));
}
#endif
if (!GeoConvHelper::init(oc)) {
throw ProcessError("Could not build projection!");
}
// check whether the input shall be pruned
bool prune = false;
if (oc.getBool("prune.on-net")) {
if (!oc.isSet("net")) {
throw ProcessError("In order to prune the input on the net, you have to supply a network.");
}
bool ok = true;
// !!! no proper error handling
Boundary offsets = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.on-net.offsets"), "--prune.on-net.offsets", 0, ok);
pruningBoundary = Boundary(
pruningBoundary.xmin()+offsets.xmin(),
pruningBoundary.ymin()+offsets.ymin(),
pruningBoundary.xmax()+offsets.xmax(),
pruningBoundary.ymax()+offsets.ymax());
prune = true;
}
if (oc.isSet("prune.boundary")) {
bool ok = true;
// !!! no proper error handling
pruningBoundary = GeomConvHelper::parseBoundaryReporting(oc.getString("prune.boundary"), "--prune.boundary", 0, ok);
prune = true;
}
PCPolyContainer toFill(prune, pruningBoundary, oc.getStringVector("remove"));
// read in the type defaults
PCTypeMap tm;
if (oc.isSet("typemap")) {
PCTypeDefHandler handler(oc, tm);
if (!XMLSubSys::runParser(handler, oc.getString("typemap"))) {
// something failed
throw ProcessError();
}
}
// read in the data
PCLoaderXML::loadIfSet(oc, toFill, tm); // SUMO-XML
PCLoaderOSM::loadIfSet(oc, toFill, tm); // OSM-XML
PCLoaderDlrNavteq::loadIfSet(oc, toFill, tm); // Elmar-files
PCLoaderVisum::loadIfSet(oc, toFill, tm); // VISUM
PCLoaderArcView::loadIfSet(oc, toFill, tm); // shape-files
// check whether any errors occured
if (!MsgHandler::getErrorInstance()->wasInformed()) {
// no? ok, save
toFill.save(oc.getString("output"));
} else {
throw ProcessError();
}
} catch (ProcessError &e) {
if (std::string(e.what())!=std::string("Process Error") && std::string(e.what())!=std::string("")) {
MsgHandler::getErrorInstance()->inform(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
SystemFrame::close();
// report about ending
if (ret==0) {
std::cout << "Success." << std::endl;
}
return ret;
}
SUMOTime
MSDevice_BTreceiver::BTreceiverUpdate::execute(SUMOTime /*currentTime*/) {
// build rtree with senders
NamedRTree rt;
for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::const_iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end(); ++i) {
MSDevice_BTsender::VehicleInformation* vi = (*i).second;
Boundary b = vi->getBoxBoundary();
b.grow(POSITION_EPS);
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
rt.Insert(cmin, cmax, vi);
}
// check visibility for all receivers
OptionsCont& oc = OptionsCont::getOptions();
bool allRecognitions = oc.getBool("device.btreceiver.all-recognitions");
bool haveOutput = oc.isSet("bt-output");
for (std::map<std::string, MSDevice_BTreceiver::VehicleInformation*>::iterator i = MSDevice_BTreceiver::sVehicles.begin(); i != MSDevice_BTreceiver::sVehicles.end();) {
// collect surrounding vehicles
MSDevice_BTreceiver::VehicleInformation* vi = (*i).second;
Boundary b = vi->getBoxBoundary();
b.grow(vi->range);
const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
std::set<std::string> surroundingVehicles;
Named::StoringVisitor sv(surroundingVehicles);
rt.Search(cmin, cmax, sv);
// loop over surrounding vehicles, check visibility status
for (std::set<std::string>::const_iterator j = surroundingVehicles.begin(); j != surroundingVehicles.end(); ++j) {
if ((*i).first == *j) {
// seeing oneself? skip
continue;
}
updateVisibility(*vi, *MSDevice_BTsender::sVehicles.find(*j)->second);
}
if (vi->haveArrived) {
// vehicle has left the simulation; remove
if (haveOutput) {
writeOutput((*i).first, vi->seen, allRecognitions);
}
delete vi;
MSDevice_BTreceiver::sVehicles.erase(i++);
} else {
// vehicle is still in the simulation; reset state
vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
++i;
}
}
// remove arrived senders / reset state
for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end();) {
MSDevice_BTsender::VehicleInformation* vi = (*i).second;
if (vi->haveArrived) {
delete vi;
MSDevice_BTsender::sVehicles.erase(i++);
} else {
vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
++i;
}
}
return DELTA_T;
}
void
Boundary::add(const Boundary& p) {
add(p.xmin(), p.ymin(), p.zmin());
add(p.xmax(), p.ymax(), p.zmax());
}
void
GUINet::initGUIStructures() {
// initialise detector storage for gui
const std::vector<SumoXMLTag> types = myDetectorControl->getAvailableTypes();
for (std::vector<SumoXMLTag>::const_iterator i = types.begin(); i != types.end(); ++i) {
const std::map<std::string, MSDetectorFileOutput*>& dets = myDetectorControl->getTypedDetectors(*i).getMyMap();
for (std::map<std::string, MSDetectorFileOutput*>::const_iterator j = dets.begin(); j != dets.end(); ++j) {
GUIDetectorWrapper* wrapper = (*j).second->buildDetectorGUIRepresentation();
if (wrapper != 0) {
myDetectorDict.push_back(wrapper);
myGrid.addAdditionalGLObject(wrapper);
}
}
}
// initialise the tl-map
initTLMap();
// initialise edge storage for gui
GUIEdge::fill(myEdgeWrapper);
// initialise junction storage for gui
size_t size = myJunctions->size();
myJunctionWrapper.reserve(size);
const std::map<std::string, MSJunction*>& junctions = myJunctions->getMyMap();
for (std::map<std::string, MSJunction*>::const_iterator i = junctions.begin(); i != junctions.end(); ++i) {
myJunctionWrapper.push_back(new GUIJunctionWrapper(*(*i).second));
}
// build the visualization tree
float* cmin = new float[2];
float* cmax = new float[2];
for (std::vector<GUIEdge*>::iterator i = myEdgeWrapper.begin(); i != myEdgeWrapper.end(); ++i) {
GUIEdge* edge = *i;
Boundary b;
const std::vector<MSLane*>& lanes = edge->getLanes();
for (std::vector<MSLane*>::const_iterator j = lanes.begin(); j != lanes.end(); ++j) {
b.add((*j)->getShape().getBoxBoundary());
}
// make sure persons are always drawn and selectable since they depend on their edge being drawn
b.grow(MSPModel::SIDEWALK_OFFSET + 1);
cmin[0] = b.xmin();
cmin[1] = b.ymin();
cmax[0] = b.xmax();
cmax[1] = b.ymax();
myGrid.Insert(cmin, cmax, edge);
myBoundary.add(b);
if (myBoundary.getWidth() > 10e16 || myBoundary.getHeight() > 10e16) {
throw ProcessError("Network size exceeds 1 Lightyear. Please reconsider your inputs.\n");
}
}
for (std::vector<GUIJunctionWrapper*>::iterator i = myJunctionWrapper.begin(); i != myJunctionWrapper.end(); ++i) {
GUIJunctionWrapper* junction = *i;
Boundary b = junction->getBoundary();
b.grow(2.);
cmin[0] = b.xmin();
cmin[1] = b.ymin();
cmax[0] = b.xmax();
cmax[1] = b.ymax();
myGrid.Insert(cmin, cmax, junction);
myBoundary.add(b);
}
delete[] cmin;
delete[] cmax;
myGrid.add(myBoundary);
}
std::string
GUISUMOAbstractView::makeSnapshot(const std::string& destFile) {
std::string errorMessage;
FXString ext = FXPath::extension(destFile.c_str());
const bool useGL2PS = ext == "ps" || ext == "eps" || ext == "pdf" || ext == "svg" || ext == "tex" || ext == "pgf";
#ifdef HAVE_FFMPEG
const bool useVideo = destFile == "" || ext == "h264" || ext == "hevc";
#endif
for (int i = 0; i < 10 && !makeCurrent(); ++i) {
FXSingleEventThread::sleep(100);
}
// draw
glClearColor(
myVisualizationSettings->backgroundColor.red() / 255.,
myVisualizationSettings->backgroundColor.green() / 255.,
myVisualizationSettings->backgroundColor.blue() / 255.,
myVisualizationSettings->backgroundColor.alpha() / 255.);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
if (myVisualizationSettings->dither) {
glEnable(GL_DITHER);
} else {
glDisable(GL_DITHER);
}
if (myVisualizationSettings->antialiase) {
glEnable(GL_BLEND);
glEnable(GL_POLYGON_SMOOTH);
glEnable(GL_LINE_SMOOTH);
} else {
glDisable(GL_BLEND);
glDisable(GL_POLYGON_SMOOTH);
glDisable(GL_LINE_SMOOTH);
}
applyGLTransform();
if (useGL2PS) {
GLint format = GL2PS_PS;
if (ext == "ps") {
format = GL2PS_PS;
} else if (ext == "eps") {
format = GL2PS_EPS;
} else if (ext == "pdf") {
format = GL2PS_PDF;
} else if (ext == "tex") {
format = GL2PS_TEX;
} else if (ext == "svg") {
format = GL2PS_SVG;
} else if (ext == "pgf") {
format = GL2PS_PGF;
} else {
return "Could not save '" + destFile + "'.\n Unrecognized format '" + std::string(ext.text()) + "'.";
}
FILE* fp = fopen(destFile.c_str(), "wb");
if (fp == 0) {
return "Could not save '" + destFile + "'.\n Could not open file for writing";
}
GLint buffsize = 0, state = GL2PS_OVERFLOW;
GLint viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
while (state == GL2PS_OVERFLOW) {
buffsize += 1024 * 1024;
gl2psBeginPage(destFile.c_str(), "sumo-gui; http://sumo.dlr.de", viewport, format, GL2PS_SIMPLE_SORT,
GL2PS_DRAW_BACKGROUND | GL2PS_USE_CURRENT_VIEWPORT,
GL_RGBA, 0, NULL, 0, 0, 0, buffsize, fp, "out.eps");
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
// compute lane width
// draw decals (if not in grabbing mode)
if (!myUseToolTips) {
drawDecals();
if (myVisualizationSettings->showGrid) {
paintGLGrid();
}
}
glLineWidth(1);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Boundary viewPort = myChanger->getViewport();
float minB[2];
float maxB[2];
minB[0] = viewPort.xmin();
minB[1] = viewPort.ymin();
maxB[0] = viewPort.xmax();
maxB[1] = viewPort.ymax();
myVisualizationSettings->scale = m2p(SUMO_const_laneWidth);
glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_POLYGON_OFFSET_LINE);
myGrid->Search(minB, maxB, *myVisualizationSettings);
if (myVisualizationSettings->showSizeLegend) {
displayLegend();
}
state = gl2psEndPage();
glFinish();
}
fclose(fp);
} else {
doPaintGL(GL_RENDER, myChanger->getViewport());
if (myVisualizationSettings->showSizeLegend) {
displayLegend();
}
swapBuffers();
glFinish();
FXColor* buf;
FXMALLOC(&buf, FXColor, getWidth()*getHeight());
// read from the back buffer
glReadBuffer(GL_BACK);
// Read the pixels
glReadPixels(0, 0, getWidth(), getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)buf);
makeNonCurrent();
update();
// mirror
size_t mwidth = getWidth();
size_t mheight = getHeight();
FXColor* paa = buf;
FXColor* pbb = buf + mwidth * (mheight - 1);
do {
FXColor* pa = paa;
paa += mwidth;
FXColor* pb = pbb;
pbb -= mwidth;
do {
FXColor t = *pa;
*pa++ = *pb;
*pb++ = t;
} while (pa < paa);
} while (paa < pbb);
try {
#ifdef HAVE_FFMPEG
if (useVideo) {
try {
saveFrame(destFile, buf);
errorMessage = "video";
} catch (std::runtime_error& err) {
errorMessage = err.what();
}
} else
#endif
if (!MFXImageHelper::saveImage(destFile, getWidth(), getHeight(), buf)) {
errorMessage = "Could not save '" + destFile + "'.";
}
} catch (InvalidArgument& e) {
errorMessage = "Could not save '" + destFile + "'.\n" + e.what();
}
FXFREE(&buf);
}
return errorMessage;
}
void
NWWriter_DlrNavteq::writeNodesUnsplitted(const OptionsCont& oc, NBNodeCont& nc, NBEdgeCont& ec, std::map<NBEdge*, std::string>& internalNodes) {
// For "real" nodes we simply use the node id.
// For internal nodes (geometry vectors describing edge geometry in the parlance of this format)
// we use the id of the edge and do not bother with
// compression (each direction gets its own internal node).
OutputDevice& device = OutputDevice::getDevice(oc.getString("dlr-navteq-output") + "_nodes_unsplitted.txt");
writeHeader(device, oc);
const GeoConvHelper& gch = GeoConvHelper::getFinal();
const bool haveGeo = gch.usingGeoProjection();
const double geoScale = pow(10.0f, haveGeo ? 5 : 2); // see NIImporter_DlrNavteq::GEO_SCALE
device.setPrecision(oc.getInt("dlr-navteq.precision"));
if (!haveGeo) {
WRITE_WARNING("DlrNavteq node data will be written in (floating point) cartesian coordinates");
}
// write format specifier
device << "# NODE_ID\tIS_BETWEEN_NODE\tamount_of_geocoordinates\tx1\ty1\t[x2 y2 ... xn yn]\n";
// write header
Boundary boundary = gch.getConvBoundary();
Position min(boundary.xmin(), boundary.ymin());
Position max(boundary.xmax(), boundary.ymax());
gch.cartesian2geo(min);
min.mul(geoScale);
gch.cartesian2geo(max);
max.mul(geoScale);
int multinodes = 0;
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
if ((*i).second->getGeometry().size() > 2) {
multinodes++;
}
}
device << "# [xmin_region] " << min.x() << "\n";
device << "# [xmax_region] " << max.x() << "\n";
device << "# [ymin_region] " << min.y() << "\n";
device << "# [ymax_region] " << max.y() << "\n";
device << "# [elements_multinode] " << multinodes << "\n";
device << "# [elements_normalnode] " << nc.size() << "\n";
device << "# [xmin] " << min.x() << "\n";
device << "# [xmax] " << max.x() << "\n";
device << "# [ymin] " << min.y() << "\n";
device << "# [ymax] " << max.y() << "\n";
// write normal nodes
for (std::map<std::string, NBNode*>::const_iterator i = nc.begin(); i != nc.end(); ++i) {
NBNode* n = (*i).second;
Position pos = n->getPosition();
gch.cartesian2geo(pos);
pos.mul(geoScale);
device << n->getID() << "\t0\t1\t" << pos.x() << "\t" << pos.y() << "\n";
}
// write "internal" nodes
std::vector<std::string> avoid;
std::set<std::string> reservedNodeIDs;
const bool numericalIDs = oc.getBool("numerical-ids");
if (oc.isSet("reserved-ids")) {
NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "node:", reservedNodeIDs); // backward compatibility
NBHelpers::loadPrefixedIDsFomFile(oc.getString("reserved-ids"), "junction:", reservedNodeIDs); // selection format
}
if (numericalIDs) {
avoid = nc.getAllNames();
std::vector<std::string> avoid2 = ec.getAllNames();
avoid.insert(avoid.end(), avoid2.begin(), avoid2.end());
avoid.insert(avoid.end(), reservedNodeIDs.begin(), reservedNodeIDs.end());
}
IDSupplier idSupplier("", avoid);
for (std::map<std::string, NBEdge*>::const_iterator i = ec.begin(); i != ec.end(); ++i) {
NBEdge* e = (*i).second;
PositionVector geom = e->getGeometry();
if (geom.size() > 2) {
// the import NIImporter_DlrNavteq checks for the presence of a
// negated edge id to determine spread type. We may need to do some
// shifting to make this consistent
const bool hasOppositeID = ec.getOppositeByID(e->getID()) != nullptr;
if (e->getLaneSpreadFunction() == LANESPREAD_RIGHT && !hasOppositeID) {
// need to write center-line geometry instead
try {
geom.move2side(e->getTotalWidth() / 2);
} catch (InvalidArgument& exception) {
WRITE_WARNING("Could not reconstruct shape for edge:'" + e->getID() + "' (" + exception.what() + ").");
}
} else if (e->getLaneSpreadFunction() == LANESPREAD_CENTER && hasOppositeID) {
// need to write left-border geometry instead
try {
geom.move2side(-e->getTotalWidth() / 2);
} catch (InvalidArgument& exception) {
WRITE_WARNING("Could not reconstruct shape for edge:'" + e->getID() + "' (" + exception.what() + ").");
}
}
std::string internalNodeID = e->getID();
if (internalNodeID == UNDEFINED
|| (nc.retrieve(internalNodeID) != nullptr)
|| reservedNodeIDs.count(internalNodeID) > 0
) {
// need to invent a new name to avoid clashing with the id of a 'real' node or a reserved name
if (numericalIDs) {
internalNodeID = idSupplier.getNext();
} else {
internalNodeID += "_geometry";
}
}
internalNodes[e] = internalNodeID;
device << internalNodeID << "\t1\t" << geom.size() - 2;
for (int ii = 1; ii < (int)geom.size() - 1; ++ii) {
Position pos = geom[(int)ii];
gch.cartesian2geo(pos);
pos.mul(geoScale);
device << "\t" << pos.x() << "\t" << pos.y();
}
device << "\n";
}
}
device.close();
}
