NBNetBuilder Class Reference

#include <NBNetBuilder.h>

---

Detailed Description

Instance responsible for building networks.

Definition at line 60 of file NBNetBuilder.h.

Public Member Functions
void	applyOptions (OptionsCont &oc) throw (ProcessError)
	Initialises the storage by applying given options.
void	buildLoaded () throw (IOError)
	Builds a network using the loaded structures and saves it.
	NBNetBuilder () throw ()
	Constructor.
	~NBNetBuilder () throw ()
	Destructor.
Retrieval of subcontainers
NBDistrictCont &	getDistrictCont () throw ()
	Returns the districts container.
NBEdgeCont &	getEdgeCont () throw ()
	Returns the edge container.
NBJunctionLogicCont &	getJunctionLogicCont () throw ()
	Returns the junction logics container.
NBNodeCont &	getNodeCont () throw ()
	Returns the node container.
NBTrafficLightLogicCont &	getTLLogicCont () throw ()
	Returns the traffic light logics container.
NBTypeCont &	getTypeCont () throw ()
	Returns the type container.
Static Public Member Functions
static void	insertNetBuildOptions (OptionsCont &oc)
	Adds net building options into the given options container.
Protected Member Functions
void	compute (OptionsCont &oc) throw (ProcessError)
	Performs the network building steps.
void	inform (int &step, const std::string &about) throw ()
	Writes information about the currently processed step.
Output methods
void	save (OutputDevice &device, OptionsCont &oc) throw (IOError)
	Saves the generated network.
Protected Attributes
NBDistrictCont	myDistrictCont
	The used container for districts.
NBEdgeCont	myEdgeCont
	The used container for edges.
NBJunctionLogicCont	myJunctionLogicCont
	The used container for junction logics.
NBNodeCont	myNodeCont
	The used container for nodes.
std::vector< std::set< NBEdge * > >	myRoundabouts
	Edges marked as belonging to a roundabout (each set is a roundabout).
NBTrafficLightLogicCont	myTLLCont
	The used container for traffic light logics.
NBTypeCont	myTypeCont
	The used container for street types.
Private Member Functions
	NBNetBuilder (const NBNetBuilder &s)
	invalidated copy constructor
NBNetBuilder &	operator= (const NBNetBuilder &s)
	invalidated assignment operator
Data Structures
class	by_id_sorter
	Sorts nodes by their ids. More...

---

Constructor & Destructor Documentation

NBNetBuilder::NBNetBuilder

(

)

throw ()

Constructor.

Definition at line 58 of file NBNetBuilder.cpp.

        : myEdgeCont(*this) {}

NBNetBuilder::~NBNetBuilder

(

)

throw ()

Destructor.

Definition at line 62 of file NBNetBuilder.cpp.

{}

NBNetBuilder::NBNetBuilder

(

const NBNetBuilder &

s

)

[private]

invalidated copy constructor

---

Member Function Documentation

void NBNetBuilder::applyOptions

(

OptionsCont &

oc

)

throw (ProcessError)

Initialises the storage by applying given options.

Options, mainly steering the acceptance of edges, are parsed and the according internal variables are set.

Parameters:

[in]

oc

The options container to read options from

Exceptions:

ProcessError

If something fails (message is included)

Definition at line 66 of file NBNetBuilder.cpp.

References NBTrafficLightLogicCont::applyOptions(), NBEdgeCont::applyOptions(), myEdgeCont, myTLLCont, myTypeCont, and NBTypeCont::setDefaults().

Referenced by main().

                                                              {
    // we possibly have to load the edges to keep
    if (oc.isSet("keep-edges.input-file")) {
        std::ifstream strm(oc.getString("keep-edges.input-file").c_str());
        if (!strm.good()) {
            throw ProcessError("Could not load names of edges too keep from '" + oc.getString("keep-edges.input-file") + "'.");
        }
        std::ostringstream oss;
        bool first = true;
        while (strm.good()) {
            if (!first) {
                oss << ',';
            }
            std::string name;
            strm >> name;
            oss << name;
            first = false;
        }
        oc.set("keep-edges", oss.str());
    }
    // check whether at least one output file is given
    if (!oc.isSet("output")&&!oc.isSet("plain-output")&&!oc.isSet("map-output")) {
        throw ProcessError("No output defined.");
    }
    // apply options to type control
    myTypeCont.setDefaults(oc.getInt("lanenumber"), oc.getFloat("speed"), oc.getInt("priority"));
    // apply options to edge control
    myEdgeCont.applyOptions(oc);
    // apply options to traffic light logics control
    myTLLCont.applyOptions(oc);
}

void NBNetBuilder::buildLoaded

(

)

throw (IOError)

Builds a network using the loaded structures and saves it.

Exceptions:

IOError

(not yet implemented)

Definition at line 100 of file NBNetBuilder.cpp.

References compute(), OutputDevice::getDevice(), OptionsCont::getOptions(), OptionsCont::getString(), gJoinedEdges, OptionsCont::isSet(), and save().

Referenced by main().

                                         {
    // perform the computation
    OptionsCont &oc = OptionsCont::getOptions();
    compute(oc);
    // save network
    OutputDevice& device = OutputDevice::getDevice(oc.getString("output"));
    save(device, oc);
    // save the mapping information when wished
    if (oc.isSet("map-output")) {
        OutputDevice& mdevice = OutputDevice::getDevice(oc.getString("map-output"));
        mdevice << gJoinedEdges;
    }
}

void NBNetBuilder::compute

(

OptionsCont &

oc

)

throw (ProcessError) [protected]

Performs the network building steps.

Performs subsequently the building steps.

Parameters:

[in]

oc

Container that contains options for building

Exceptions:

ProcessError

(recheck)

Definition at line 116 of file NBNetBuilder.cpp.

References NBEdgeCont::appendTurnarounds(), NBEdgeCont::computeEdge2Edges(), NBEdgeCont::computeEdgeShapes(), NBEdgeCont::computeLanes2Edges(), NBNodeCont::computeLanes2Lanes(), NBTrafficLightLogicCont::computeLogics(), NBNodeCont::computeLogics(), NBNodeCont::computeNodeShapes(), NBEdgeCont::computeTurningDirections(), OutputDevice::createDeviceByOption(), GeoConvHelper::getConvBoundary(), GeoConvHelper::getOffsetBase(), GeoConvHelper::getOrigBoundary(), gJoinedEdges, gSuppressMessages, NBNodeCont::guessRamps(), NBEdgeCont::guessRoundabouts(), NBNodeCont::guessTLs(), inform(), NBJoinedEdgesMap::init(), NBNodeCont::joinTLS(), GeoConvHelper::moveConvertedBy(), myDistrictCont, myEdgeCont, myJunctionLogicCont, myNodeCont, myRoundabouts, myTLLCont, myTypeCont, NBNodeCont::printBuiltNodesStatistics(), NBNodeCont::recheckEdges(), NBEdgeCont::recheckLanes(), NBEdgeCont::recomputeLaneShapes(), NBNodeCont::removeDummyEdges(), NBNodeCont::removeIsolatedRoads(), NBEdgeCont::removeUnwishedEdges(), NBNodeCont::removeUnwishedNodes(), NBRequest::reportWarnings(), NBDistrictCont::reshiftDistrictPositions(), NBEdgeCont::reshiftEdgePositions(), NBNodeCont::reshiftNodePositions(), NBNodeCont::retrieve(), NBEdgeCont::savePlain(), NBNodeCont::savePlain(), NBNodeCont::setAsTLControlled(), NBTrafficLightLogicCont::setTLControllingInformation(), NBNodeCont::sortNodesEdges(), NBEdgeCont::sortOutgoingLanesConnections(), NBEdgeCont::splitGeometry(), SUMOReal, toString(), WRITE_MESSAGE, WRITE_WARNING, Boundary::xmin(), and Boundary::ymin().

Referenced by buildLoaded().

                                                         {
    int step = 1;
    //
    // Removes edges that are connecting the same node
    inform(step, "Removing dummy edges.");
    myNodeCont.removeDummyEdges(myDistrictCont, myEdgeCont, myTLLCont);
    //
    inform(step, "Joining double connections.");
    gJoinedEdges.init(myEdgeCont);
    myNodeCont.recheckEdges(myDistrictCont, myTLLCont, myEdgeCont);
    //
    if (oc.getBool("remove-isolated")) {
        inform(step, "Finding isolated roads.");
        myNodeCont.removeIsolatedRoads(myDistrictCont, myEdgeCont, myTLLCont);
    }
    //
    if (oc.getBool("remove-geometry")) {
        inform(step, "Removing empty nodes and geometry nodes.");
        myNodeCont.removeUnwishedNodes(myDistrictCont, myEdgeCont, myTLLCont, oc.getBool("remove-geometry"));
    }
    //
    if (oc.getBool("keep-edges.postload")) {
        if (oc.isSet("keep-edges")) {
            inform(step, "Removing unwished edges.");
            myEdgeCont.removeUnwishedEdges(myDistrictCont);
        }
    }
    if (oc.isSet("keep-edges") || oc.isSet("remove-edges") || oc.getBool("keep-edges.postload") || oc.isSet("keep-edges.by-vclass") || oc.isSet("keep-edges.input-file")) {
        inform(step, "Rechecking nodes after edge removal.");
        myNodeCont.removeUnwishedNodes(myDistrictCont, myEdgeCont, myTLLCont, oc.getBool("remove-geometry"));
    }
    //
    if (oc.getBool("split-geometry")) {
        inform(step, "Splitting geometry edges.");
        myEdgeCont.splitGeometry(myNodeCont);
    }
    //
    if (!oc.getBool("disable-normalize-node-positions") && oc.isDefault("x-offset-to-apply") && oc.isDefault("y-offset-to-apply")) {
        inform(step, "Normalising node positions.");
        const SUMOReal x = -GeoConvHelper::getConvBoundary().xmin();
        const SUMOReal y = -GeoConvHelper::getConvBoundary().ymin();
        myNodeCont.reshiftNodePositions(x, y);
        myEdgeCont.reshiftEdgePositions(x, y);
        myDistrictCont.reshiftDistrictPositions(x, y);
        GeoConvHelper::moveConvertedBy(x, y);
    }
    //
    myEdgeCont.recomputeLaneShapes();
    //
    if (oc.getBool("guess-ramps")||oc.getBool("guess-obscure-ramps")||oc.isSet("ramp-guess.explicite")) {
        inform(step, "Guessing and setting on-/off-ramps.");
        myNodeCont.guessRamps(oc, myEdgeCont, myDistrictCont);
    }
    //
    inform(step, "Guessing and setting TLs.");
    if (oc.isSet("explicite-tls")) {
        std::vector<std::string> tlControlledNodes = oc.getStringVector("explicite-tls");
        for (std::vector<std::string>::const_iterator i=tlControlledNodes.begin(); i!=tlControlledNodes.end(); ++i) {
            NBNode *node = myNodeCont.retrieve(*i);
            if (node==0) {
                WRITE_WARNING("Building a tl-logic for node '" + *i + "' is not possible." + "\n The node '" + *i + "' is not known.");
            } else {
                myNodeCont.setAsTLControlled(node, myTLLCont);
            }
        }
    }
    myNodeCont.guessTLs(oc, myTLLCont);
    //
    if (oc.getBool("try-join-tls")) {
        myNodeCont.joinTLS(myTLLCont);
    }
    //
    inform(step, "Computing turning directions.");
    myEdgeCont.computeTurningDirections();
    //
    OutputDevice::createDeviceByOption("node-type-output", "pois");
    inform(step, "Sorting nodes' edges.");
    myNodeCont.sortNodesEdges(oc.getBool("lefthand"), myTypeCont);
    //
    if (oc.getBool("guess-roundabouts")) {
        inform(step, "Guessing and setting roundabouts.");
        myEdgeCont.guessRoundabouts(myRoundabouts);
    }
    //
    inform(step, "Computing approached edges.");
    myEdgeCont.computeEdge2Edges();
    //
    inform(step, "Computing approaching lanes.");
    myEdgeCont.computeLanes2Edges();
    //
    inform(step, "Dividing of lanes on approached lanes.");
    myNodeCont.computeLanes2Lanes();
    myEdgeCont.sortOutgoingLanesConnections();
    //
    if (!oc.getBool("no-turnarounds")) {
        inform(step, "Appending turnarounds.");
        myEdgeCont.appendTurnarounds(oc.getBool("no-tls-turnarounds"));
    }
    //
    inform(step, "Rechecking of lane endings.");
    myEdgeCont.recheckLanes();
    // save plain nodes/edges/connections
    if (oc.isSet("plain-output")) {
        myNodeCont.savePlain(oc.getString("plain-output") + ".nod.xml");
        myEdgeCont.savePlain(oc.getString("plain-output") + ".edg.xml", oc.getString("plain-output") + ".con.xml");
    }
    //
    inform(step, "Computing node shapes.");
    myNodeCont.computeNodeShapes(oc.getBool("lefthand"));
    //
    inform(step, "Computing edge shapes.");
    myEdgeCont.computeEdgeShapes();
    //
    inform(step, "Computing tls logics.");
    myTLLCont.setTLControllingInformation(myEdgeCont);
    //
    inform(step, "Computing node logics.");
    myNodeCont.computeLogics(myEdgeCont, myJunctionLogicCont, oc);
    //
    inform(step, "Computing traffic light logics.");
    myTLLCont.computeLogics(myEdgeCont, oc);
    // report
    WRITE_MESSAGE("-----------------------------------------------------");
    WRITE_MESSAGE("Summary:");
    if (!gSuppressMessages) {
        myNodeCont.printBuiltNodesStatistics();
    }
    WRITE_MESSAGE(" Network boundaries:");
    WRITE_MESSAGE("  Original boundary  : " + toString(GeoConvHelper::getOrigBoundary()));
    WRITE_MESSAGE("  Applied offset     : " + toString(GeoConvHelper::getOffsetBase()));
    WRITE_MESSAGE("  Converted boundary : " + toString(GeoConvHelper::getConvBoundary()));
    WRITE_MESSAGE("-----------------------------------------------------");
    NBRequest::reportWarnings();
}

NBDistrictCont& NBNetBuilder::getDistrictCont

(

)

throw () [inline]

Returns the districts container.

Returns:

The districts container (reference)

Definition at line 134 of file NBNetBuilder.h.

References myDistrictCont.

Referenced by NIImporter_VISUM::buildDistrictNode(), NILoader::load(), NILoader::loadXML(), NIImporter_VISUM::parse_Connectors(), NIImporter_VISUM::parse_Districts(), NIImporter_VISUM::parse_Lanes(), and NIImporter_Vissim::postLoadBuild().

                                              {
        return myDistrictCont;
    }

NBEdgeCont& NBNetBuilder::getEdgeCont

(

)

throw () [inline]

Returns the edge container.

Returns:

The edge container (reference)

Definition at line 94 of file NBNetBuilder.h.

References myEdgeCont.

Referenced by NIImporter_VISUM::getNamedEdge(), NIImporter_VISUM::getNamedEdgeContinuating(), NIImporter_VISUM::getReversedContinuating(), NILoader::load(), NIImporter_SUMO::loadNetwork(), NIImporter_RobocupRescue::loadNetwork(), NIImporter_OpenStreetMap::loadNetwork(), NIImporter_OpenDrive::loadNetwork(), NIImporter_DlrNavteq::loadNetwork(), NIImporter_ArcView::loadNetwork(), NILoader::loadXML(), main(), NIImporter_VISUM::parse_Connectors(), NIImporter_VISUM::parse_Edges(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_LanesConnections(), NIImporter_VISUM::parse_TurnsToSignalGroups(), NIImporter_Vissim::postLoadBuild(), and NGNet::toNB().

                                      {
        return myEdgeCont;
    }

NBJunctionLogicCont& NBNetBuilder::getJunctionLogicCont

(

)

throw () [inline]

Returns the junction logics container.

Returns:

The junction logics container (reference)

Definition at line 126 of file NBNetBuilder.h.

References myJunctionLogicCont.

                                                        {
        return myJunctionLogicCont;
    }

NBNodeCont& NBNetBuilder::getNodeCont

(

)

throw () [inline]

Returns the node container.

Returns:

The node container (reference)

Definition at line 102 of file NBNetBuilder.h.

References myNodeCont.

Referenced by NIImporter_VISUM::buildDistrictNode(), NIImporter_VISUM::getNamedNode(), NILoader::load(), NIImporter_SUMO::loadNetwork(), NIImporter_RobocupRescue::loadNetwork(), NIImporter_OpenStreetMap::loadNetwork(), NIImporter_OpenDrive::loadNetwork(), NIImporter_DlrNavteq::loadNetwork(), NIImporter_ArcView::loadNetwork(), NILoader::loadXML(), main(), NIImporter_VISUM::parse_Lanes(), NIImporter_VISUM::parse_Nodes(), NIImporter_VISUM::parse_NodesToTrafficLights(), NIImporter_Vissim::postLoadBuild(), and NGNet::toNB().

                                      {
        return myNodeCont;
    }

NBTrafficLightLogicCont& NBNetBuilder::getTLLogicCont

(

)

throw () [inline]

Returns the traffic light logics container.

Returns:

The traffic light logics container (reference)

Definition at line 118 of file NBNetBuilder.h.

References myTLLCont.

Referenced by NIImporter_VISUM::load(), NIImporter_OpenStreetMap::loadNetwork(), NIImporter_DlrNavteq::loadNetwork(), NILoader::loadXML(), and NIImporter_Vissim::postLoadBuild().

                                                      {
        return myTLLCont;
    }

NBTypeCont& NBNetBuilder::getTypeCont

(

)

throw () [inline]

Returns the type container.

Returns:

The type container (reference)

Definition at line 110 of file NBNetBuilder.h.

References myTypeCont.

Referenced by NBEdgeCont::insert(), NILoader::load(), NIImporter_OpenStreetMap::loadNetwork(), NIImporter_OpenDrive::loadNetwork(), NIImporter_ArcView::loadNetwork(), NILoader::loadXML(), NIImporter_VISUM::parse_Edges(), NIImporter_VISUM::parse_Types(), and NGNet::toNB().

                                      {
        return myTypeCont;
    }

void NBNetBuilder::inform	(	int &	step,
		const std::string &	about
	)			throw () [protected]

Writes information about the currently processed step.

Parameters:

[in,out]	step	The current building step (incremented)
[in]	Brief	description about what is done in this step

Definition at line 253 of file NBNetBuilder.cpp.

References WRITE_MESSAGE.

Referenced by compute().

                                                              {
    WRITE_MESSAGE("Computing step " + toString<int>(step)+ ": " + about);
    step++;
}

void NBNetBuilder::insertNetBuildOptions

(

OptionsCont &

oc

)

[static]

Adds net building options into the given options container.

Parameters:

[in]

oc

The options container to add net building options to

Definition at line 331 of file NBNetBuilder.cpp.

References OptionsCont::addDescription(), OptionsCont::addSynonyme(), OptionsCont::doRegister(), and SUMOReal.

Referenced by NIOptionsIO::fillOptions(), and fillOptions().

                                                   {
    // register additional output options
    oc.doRegister("output-file", 'o', new Option_FileName("net.net.xml"));
    oc.addSynonyme("output-file", "output");
    oc.addDescription("output-file", "Output", "The generated net will be written to FILE");

    oc.doRegister("plain-output", new Option_FileName());
    oc.addDescription("plain-output", "Output", "Prefix of files to write nodes and edges to");

    oc.doRegister("node-geometry-dump", new Option_FileName());
    oc.addDescription("node-geometry-dump", "Output", "Writes node corner positions to FILE");

    oc.doRegister("map-output", 'M', new Option_FileName());
    oc.addDescription("map-output", "Output", "Writes joined edges information to FILE");

    oc.doRegister("node-type-output", new Option_FileName());
    oc.addDescription("node-type-output", "Output", "Writes pois of node types to FILE"); // !!! describe, rename



    // register building defaults
    oc.doRegister("type", 'T', new Option_String("Unknown"));
    oc.addDescription("type", "Building Defaults", "The default name for an edges type");

    oc.doRegister("lanenumber", 'L', new Option_Integer(1));
    oc.addDescription("lanenumber", "Building Defaults", "The default number of lanes in an edge");

    oc.doRegister("speed", 'S', new Option_Float((SUMOReal) 13.9));
    oc.addDescription("speed", "Building Defaults", "The default speed on an edge (in m/s)");

    oc.doRegister("priority", 'P', new Option_Integer(-1));
    oc.addDescription("priority", "Building Defaults", "The default priority of an edge");


    // register the data processing options
    oc.doRegister("flip-y", new Option_Bool(false));
    oc.addDescription("flip-y", "Processing", "Flips the y-coordinate along zero");

    oc.doRegister("dismiss-vclasses", new Option_Bool(false));
    oc.addDescription("dismiss-vclasses", "Processing", "");

    oc.doRegister("remove-geometry", 'R', new Option_Bool(false));
    oc.addDescription("remove-geometry", "Processing", "Removes geometry information from edges");

    oc.doRegister("remove-isolated", new Option_Bool(false));
    oc.addDescription("remove-isolated", "Processing", "Removes isolated edges");

    oc.doRegister("no-turnarounds", new Option_Bool(false));
    oc.addDescription("no-turnarounds", "Processing", "Disables building turnarounds");
    oc.doRegister("no-tls-turnarounds", new Option_Bool(false));
    oc.addDescription("no-tls-turnarounds", "Processing", "Disables building turnarounds at tls-controlled junctions");

    oc.doRegister("no-internal-links", new Option_Bool(false)); // !!! not described
    oc.addDescription("no-internal-links", "Processing", "Omits internal links");

    oc.doRegister("split-geometry", new Option_Bool(false)); // !!!not described
    oc.addDescription("split-geometry", "Processing", "Splits edges across geometry nodes");

    oc.doRegister("disable-normalize-node-positions", new Option_Bool(false));
    oc.addDescription("disable-normalize-node-positions", "Processing", "Turn off normalizing node positions");

    oc.doRegister("x-offset-to-apply", new Option_Float(0));
    oc.addDescription("x-offset-to-apply", "Processing", "Adds FLOAT to net x-positions");

    oc.doRegister("y-offset-to-apply", new Option_Float(0));
    oc.addDescription("y-offset-to-apply", "Processing", "Adds FLOAT to net y-positions");

    oc.doRegister("guess-roundabouts", new Option_Bool(false));
    oc.addDescription("guess-roundabouts", "Processing", "Enable roundabout-guessing");

    oc.doRegister("lefthand", new Option_Bool(false));
    oc.addDescription("lefthand", "Processing", "Assumes left-hand traffic on the network");


    // tls setting options
    // explicite tls
    oc.doRegister("explicite-tls", new Option_String());
    oc.addDescription("explicite-tls", "TLS Building", "Interprets STR as list of junctions to be controlled by TLS");

    oc.doRegister("explicite-no-tls", new Option_String());
    oc.addDescription("explicite-no-tls", "TLS Building", "Interprets STR as list of junctions to be not controlled by TLS");

    // tls-guessing
    oc.doRegister("guess-tls", new Option_Bool(false));
    oc.addDescription("guess-tls", "TLS Building", "Turns on TLS guessing");

    oc.doRegister("tls-guess.district-nodes", new Option_Bool(false));
    oc.addDescription("tls-guess.district-nodes", "TLS Building", "Sets district nodes as tls-controlled"); // !!! describe

    oc.doRegister("tls-guess.joining", new Option_Bool(false));
    oc.addDescription("tls-guess.joining", "TLS Building", "Includes node clusters into guess"); // !!! describe

    oc.doRegister("try-join-tls", new Option_Bool(false));
    oc.addDescription("try-join-tls", "TLS Building", "Tries to cluster tls-controlled nodes"); // !!! describe

    // computational
    oc.doRegister("min-decel", 'D', new Option_Float(3.0));
    oc.addDescription("min-decel", "TLS Building", "Defines smallest vehicle deceleration");

    oc.doRegister("patch-small-tyellow", new Option_Bool(false));
    oc.addDescription("patch-small-tyellow", "TLS Building", "Given yellow times are patched even if being too short");

    oc.doRegister("traffic-light-green", new Option_Integer());
    oc.addDescription("traffic-light-green", "TLS Building", "Use INT as green phase duration");

    oc.doRegister("traffic-light-yellow", new Option_Integer());
    oc.addDescription("traffic-light-yellow", "TLS Building", "Set INT as fixed time for yellow phase durations");

    // tls-shifts
    oc.doRegister("tl-logics.half-offset", new Option_String());
    oc.addDescription("tl-logics.half-offset", "TLS Building", "TLSs in STR will be shifted by half-phase");

    oc.doRegister("tl-logics.quarter-offset", new Option_String());
    oc.addDescription("tl-logics.quarter-offset", "TLS Building", "TLSs in STR will be shifted by quarter-phase");


    // edge constraints
    oc.doRegister("edges-min-speed", new Option_Float());
    oc.addDescription("edges-min-speed", "Edge Removal", "Remove edges with speed < FLOAT");

    oc.doRegister("remove-edges", new Option_String());
    oc.addDescription("remove-edges", "Edge Removal", "Remove edges in STR");

    oc.doRegister("keep-edges", new Option_String());
    oc.addDescription("keep-edges", "Edge Removal", "Remove edges not in STR");

    oc.doRegister("keep-edges.input-file", new Option_FileName());
    oc.addDescription("keep-edges.input-file", "Edge Removal", "Removed edges not in FILE");

    oc.doRegister("keep-edges.postload", new Option_Bool(false));
    oc.addDescription("keep-edges.postload", "Edge Removal", "Remove edges after joining");

    oc.doRegister("keep-edges.in-boundary", new Option_String());
    oc.addDescription("keep-edges.in-boundary", "Edge Removal", "Keeps edges which are located within the given boundary");

    oc.doRegister("remove-edges.by-vclass", new Option_String());
    oc.addDescription("remove-edges.by-vclass", "Edge Removal", "Remove edges where vclass def is not in STR");


    // unregulated nodes options
    oc.doRegister("keep-unregulated", new Option_Bool(false));
    oc.addDescription("keep-unregulated", "Unregulated Nodes", "All nodes will be not regulated");

    oc.doRegister("keep-unregulated.nodes", new Option_String());
    oc.addDescription("keep-unregulated.nodes", "Unregulated Nodes", "Do not regulate nodes in STR");

    oc.doRegister("keep-unregulated.district-nodes", new Option_Bool(false));
    oc.addDescription("keep-unregulated.district-nodes", "Unregulated Nodes", "Do not regulate district nodes");


    // ramp guessing options
    oc.doRegister("guess-ramps", new Option_Bool(false));
    oc.addDescription("guess-ramps", "Ramp Guessing", "Enable ramp-guessing");

    oc.doRegister("ramp-guess.max-ramp-speed", new Option_Float(-1));
    oc.addDescription("ramp-guess.max-ramp-speed", "Ramp Guessing", "Treat edges with speed > FLOAT as no ramps");

    oc.doRegister("ramp-guess.min-highway-speed", new Option_Float((SUMOReal)(79/3.6)));
    oc.addDescription("ramp-guess.min-highway-speed", "Ramp Guessing", "Treat edges with speed < FLOAT as no highways");

    oc.doRegister("ramp-guess.ramp-length", new Option_Float(100));
    oc.addDescription("ramp-guess.ramp-length", "Ramp Guessing", "Use FLOAT as ramp-length");

    oc.doRegister("ramp-guess.explicite", new Option_String());
    oc.addDescription("ramp-guess.explicite", "Ramp Guessing", "Tries to handle the given edges as ramps");

    oc.doRegister("guess-obscure-ramps", new Option_Bool(false)); // !!! not described
    oc.addDescription("guess-obscure-ramps", "Ramp Guessing", "");

    oc.doRegister("obscure-ramps.add-ramp", new Option_Bool(false)); // !!! not described
    oc.addDescription("obscure-ramps.add-ramp", "Ramp Guessing", "");

    oc.doRegister("obscure-ramps.min-highway-speed", new Option_Float((SUMOReal)(100/3.6)));  // !!! not described
    oc.addDescription("obscure-ramps.min-highway-speed", "Ramp Guessing", "");


}

NBNetBuilder& NBNetBuilder::operator=

(

const NBNetBuilder &

s

)

[private]

invalidated assignment operator

void NBNetBuilder::save	(	OutputDevice &	device,
		OptionsCont &	oc
	)			throw (IOError) [protected]

Saves the generated network.

Instances the network is made of are written by called methods from sub-containers.

Parameters:

[in]	device	The device to write the network into
[in]	oc	Options needed to know what shall be saved (mainly whether internal links shall be saved)

Exceptions:

IOError

(not yet implemented)

See also:

NBDistrictCont::writeXML

NBEdgeCont::writeXMLStep1

NBJunctionLogicCont::writeXML

NBTrafficLightLogicCont::writeXML

NBNodeCont::writeXML

NBNodeCont::writeXMLInternalNodes

NBEdgeCont::writeXMLStep2

NBNodeCont::writeXMLInternalSuccInfos

Definition at line 262 of file NBNetBuilder.cpp.

References GEO_OUTPUT_ACCURACY, GeoConvHelper::getConvBoundary(), GeoConvHelper::getOffsetBase(), GeoConvHelper::getOrigBoundary(), GeoConvHelper::getProjString(), myDistrictCont, myEdgeCont, myJunctionLogicCont, myNodeCont, myRoundabouts, myTLLCont, GeoConvHelper::usingGeoProjection(), NBNodeCont::writeXML(), NBTrafficLightLogicCont::writeXML(), NBJunctionLogicCont::writeXML(), NBDistrictCont::writeXML(), NBNodeCont::writeXMLInternalLinks(), NBNodeCont::writeXMLInternalNodes(), NBNodeCont::writeXMLInternalSuccInfos(), NBEdgeCont::writeXMLStep1(), and NBEdgeCont::writeXMLStep2().

Referenced by buildLoaded().

                                                                       {
    device.writeXMLHeader("net");
    device << "\n";
    // write network offsets
    device << "   <location netOffset=\"" << GeoConvHelper::getOffsetBase() << "\""
    << " convBoundary=\"" << GeoConvHelper::getConvBoundary() << "\"";
    if (GeoConvHelper::usingGeoProjection()) {
        device.setPrecision(GEO_OUTPUT_ACCURACY);
        device << " origBoundary=\"" << GeoConvHelper::getOrigBoundary() << "\"";
        device.setPrecision();
    } else {
        device << " origBoundary=\"" << GeoConvHelper::getOrigBoundary() << "\"";
    }
    device << " projParameter=\"" << GeoConvHelper::getProjString() << "\"/>\n\n";

    // write the numbers of some elements
    // edges
    if (!oc.getBool("no-internal-links")) {
        myNodeCont.writeXMLInternalLinks(device);
    }

    // write the districts
    myDistrictCont.writeXML(device);
    // write edges with lanes and connected edges
    myEdgeCont.writeXMLStep1(device);
    // write the logics
    myJunctionLogicCont.writeXML(device);
    myTLLCont.writeXML(device);
    // write the nodes
    myNodeCont.writeXML(device);
    // write internal nodes
    if (!oc.getBool("no-internal-links")) {
        myNodeCont.writeXMLInternalNodes(device);
    }
    // write the successors of lanes
    myEdgeCont.writeXMLStep2(device, !oc.getBool("no-internal-links"));
    if (!oc.getBool("no-internal-links")) {
        myNodeCont.writeXMLInternalSuccInfos(device);
    }
    // write roundabout information
    for (std::vector<std::set<NBEdge*> >::iterator i=myRoundabouts.begin(); i!=myRoundabouts.end(); ++i) {
        std::vector<NBNode*> nodes;
        for (std::set<NBEdge*>::iterator j=(*i).begin(); j!=(*i).end(); ++j) {
            NBNode *n = (*j)->getToNode();
            if (find(nodes.begin(), nodes.end(), n)==nodes.end()) {
                nodes.push_back(n);
            }
        }
        sort(nodes.begin(), nodes.end(), by_id_sorter());
        device << "   <roundabout nodes=\"";
        int k = 0;
        for (std::vector<NBNode*>::iterator j=nodes.begin(); j!=nodes.end(); ++j, ++k) {
            if (k!=0) {
                device << ' ';
            }
            device << (*j)->getID();
        }
        device << "\"/>\n";
    }
    if (myRoundabouts.size()!=0) {
        device << "\n";
    }
    device.close();
}

---

Field Documentation

NBDistrictCont NBNetBuilder::myDistrictCont [protected]

The used container for districts.

Definition at line 226 of file NBNetBuilder.h.

Referenced by compute(), getDistrictCont(), and save().

NBEdgeCont NBNetBuilder::myEdgeCont [protected]

The used container for edges.

Definition at line 211 of file NBNetBuilder.h.

Referenced by applyOptions(), compute(), getEdgeCont(), and save().

NBJunctionLogicCont NBNetBuilder::myJunctionLogicCont [protected]

The used container for junction logics.

Definition at line 223 of file NBNetBuilder.h.

Referenced by compute(), getJunctionLogicCont(), and save().

NBNodeCont NBNetBuilder::myNodeCont [protected]

The used container for nodes.

Definition at line 214 of file NBNetBuilder.h.

Referenced by compute(), getNodeCont(), and save().

std::vector<std::set<NBEdge*> > NBNetBuilder::myRoundabouts [protected]

Edges marked as belonging to a roundabout (each set is a roundabout).

Definition at line 229 of file NBNetBuilder.h.

Referenced by compute(), and save().

NBTrafficLightLogicCont NBNetBuilder::myTLLCont [protected]

The used container for traffic light logics.

Definition at line 220 of file NBNetBuilder.h.

Referenced by applyOptions(), compute(), getTLLogicCont(), and save().

NBTypeCont NBNetBuilder::myTypeCont [protected]

The used container for street types.

Definition at line 217 of file NBNetBuilder.h.

Referenced by applyOptions(), compute(), and getTypeCont().

---

The documentation for this class was generated from the following files:

• NBNetBuilder.h
• NBNetBuilder.cpp