NWWriter_SUMO.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Exporter writing networks using the SUMO format
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <netbuild/NBEdge.h>
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/common/UtilExceptions.h>
#include <netbuild/NBConnectionDefs.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class OptionsCont;
class NBNetBuilder;
class NBTrafficLightLogic;
class NBTrafficLightLogicCont;
class NBNode;
class NBDistrict;
class NBEdgeControl;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NWWriter_SUMO {
public:
 
    enum ConnectionStyle {
        SUMONET, // all connection information
        PLAIN,   // only edges and link indices
        TLL      // like plain but include tl information
    };
 
    static void writeNetwork(const OptionsCont& oc, NBNetBuilder& nb);
 
 
    static void writeConnection(OutputDevice& into, const NBEdge& from, const NBEdge::Connection& c,
                                bool includeInternal, ConnectionStyle style = SUMONET, bool geoAccuracy = false);
 
    static void writeProhibitions(OutputDevice& into, const NBConnectionProhibits& prohibitions);
 
    static void writeTrafficLights(OutputDevice& into, const NBTrafficLightLogicCont& tllCont);
 
    static void writeTrafficLight(OutputDevice& into, const NBTrafficLightLogic* logic);
 
    static void writeRoundabouts(OutputDevice& into, const std::set<EdgeSet>& roundabouts,
                                 const NBEdgeCont& ec);
 
    static void writeStopOffsets(OutputDevice& into, const StopOffset& stopOffset);
 
    static void writeDistrict(OutputDevice& into, const NBDistrict& d);
 
 
private:
 
    static bool writeInternalEdges(OutputDevice& into, const NBEdgeCont& ec, const NBNode& n);
 
 
    static std::string getInternalBidi(const NBEdge* e, const NBEdge::Connection& k, double& length);
 
 
    static void writeEdge(OutputDevice& into, const NBEdge& e, bool noNames);
 
 
    static void writeLane(OutputDevice& into, const std::string& lID,
                          double speed, double friction,
                          SVCPermissions permissions, SVCPermissions preferred,
                          SVCPermissions changeLeft, SVCPermissions changeRight,
                          double startOffset, double endOffset,
                          const StopOffset& stopOffset, double width, PositionVector shape,
                          const Parameterised* params, double length, int index,
                          const std::string& oppositeID, const std::string& type,
                          bool accelRamp = false,
                          bool customShape = false,
                          const PositionVector& outlineShape = PositionVector());
 
 
    static void writeJunction(OutputDevice& into, const NBNode& n);
 
 
    static bool writeInternalNodes(OutputDevice& into, const NBNode& n);
 
 
    static bool writeInternalConnections(OutputDevice& into, const NBNode& n);
 
 
    static void writeInternalConnection(OutputDevice& into,
                                        const std::string& from, const std::string& to,
                                        int fromLane, int toLane, const std::string& via,
                                        LinkDirection dir = LinkDirection::STRAIGHT,
                                        const std::string& tlID = "",
                                        int linkIndex = NBConnection::InvalidTlIndex,
                                        bool minor = false,
                                        double visibility = NBEdge::UNSPECIFIED_VISIBILITY_DISTANCE);
 
    static std::string writeSUMOTime(SUMOTime time);
 
    static std::string prohibitionConnection(const NBConnection& c);
 
    static void writeRoundabout(OutputDevice& into, const std::vector<std::string>& r,
                                const NBEdgeCont& ec);
 
    static std::string getOppositeInternalID(const NBEdgeCont& ec, const NBEdge* from, const NBEdge::Connection& con, double& oppositeLength);
 
};