NIVissimEdge.h

Go to the documentation of this file.

/****************************************************************************/
// A temporary storage for edges imported from Vissim
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef NIVissimEdge_h
#define NIVissimEdge_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include "NIVissimConnectionCluster.h"
#include <vector>
#include <string>
#include <map>
#include <netbuild/NBEdge.h>
#include <utils/geom/PositionVector.h>
#include <utils/common/VectorHelper.h>
#include <utils/common/UtilExceptions.h>
#include "NIVissimAbstractEdge.h"
#include "NIVissimClosedLanesVector.h"


// ===========================================================================
// class declarations
// ===========================================================================
class NBNode;
class NIVissimDistrictConnection;
class NBDistribution;
class NBDistrictCont;


// ===========================================================================
// class definitions
// ===========================================================================
class NIVissimEdge
        : public NIVissimAbstractEdge {
public:
    NIVissimEdge(int id, const std::string& name,
                 const std::string& type, int noLanes, SUMOReal zuschlag1,
                 SUMOReal zuschlag2, SUMOReal length,
                 const PositionVector& geom,
                 const NIVissimClosedLanesVector& clv);

    ~NIVissimEdge();

    void setNodeCluster(int nodeid);
    void buildGeom();

    void addIncomingConnection(int id);

    void addOutgoingConnection(int id);

    NBNode* getNodeAt(const Position& p, NBNode* other=0);

    Position getBegin2D() const;

    Position getEnd2D() const;

    SUMOReal getLength() const;

    void checkDistrictConnectionExistanceAt(SUMOReal pos);

    void mergedInto(NIVissimConnectionCluster* old,
                    NIVissimConnectionCluster* act);

    void removeFromConnectionCluster(NIVissimConnectionCluster* c);
    void addToConnectionCluster(NIVissimConnectionCluster* c);
    void setSpeed(size_t lane, int speedDist);
    bool addToTreatAsSame(NIVissimEdge* e);

    NIVissimConnection* getConnectionTo(NIVissimEdge* e);
    const std::vector<NIVissimEdge*> &getToTreatAsSame() const;


    bool wasWithinAJunction() const throw() {
        return myAmWithinJunction;
    }

    NIVissimEdge* getBestIncoming() const throw();
    NIVissimEdge* getBestOutgoing() const throw();

    friend class NIVissimNodeDef_Edges;
    friend class NIVissimNodeDef_Poly;

public:
    static bool dictionary(int id, const std::string& name,
                           const std::string& type, int noLanes, SUMOReal zuschlag1,
                           SUMOReal zuschlag2, SUMOReal length,
                           const PositionVector& geom,
                           const NIVissimClosedLanesVector& clv);

    static bool dictionary(int id, NIVissimEdge* o);

    static NIVissimEdge* dictionary(int id);

    static void buildConnectionClusters() throw();

    static void dict_buildNBEdges(NBDistrictCont& dc, NBNodeCont& nc,
                                  NBEdgeCont& ec, SUMOReal offset);

    static void dict_propagateSpeeds(/* NBDistribution &dc */);

    static void dict_checkEdges2Join();


    static void reportUnsetSpeeds() throw();


private:
    typedef std::vector<NIVissimConnectionCluster*> ConnectionClusters;

private:
    void buildNBEdge(NBDistrictCont& dc, NBNodeCont& nc,
                     NBEdgeCont& ec, SUMOReal sameNodesOffset) throw(ProcessError);

    std::pair<NIVissimConnectionCluster*, NBNode*>
    getFromNode(NBNodeCont& nc, ConnectionClusters& clusters);

    std::pair<NIVissimConnectionCluster*, NBNode*>
    getToNode(NBNodeCont& nc, ConnectionClusters& clusters);

    std::pair<NBNode*, NBNode*> resolveSameNode(NBNodeCont& nc,
            SUMOReal offset, NBNode* prevFrom, NBNode* prevTo);

//    SUMOReal recheckSpeedPatches();

    std::vector<NIVissimConnection*> getOutgoingConnected(int lane) const;

    void propagateSpeed(/* NBDistribution &dc */SUMOReal speed, IntVector forLanes);


    void setDistrictSpeed(/* NBDistribution &dc */);
    SUMOReal getRealSpeed(/* NBDistribution &dc */int distNo);
    void checkUnconnectedLaneSpeeds(/* NBDistribution &dc */);
    void propagateOwn(/* NBDistribution &dc */);



private:
    static NBNode* getNodeSecure(int nodeid, const Position& pos,
                                 const std::string& possibleName);

    std::pair<NBNode*, NBNode*>
    remapOneOfNodes(NBNodeCont& nc,
                    NIVissimDistrictConnection* d,
                    NBNode* fromNode, NBNode* toNode);

private:
    class connection_position_sorter {
    public:
        explicit connection_position_sorter(int edgeid);

        int operator()(int c1id, int c2id) const;

    private:
        int myEdgeID;

    };


    class connection_cluster_position_sorter {
    public:
        explicit connection_cluster_position_sorter(int edgeid);

        int operator()(NIVissimConnectionCluster* cc1,
                       NIVissimConnectionCluster* cc2) const;

    private:
        int myEdgeID;

    };

private:
    std::string myName;

    std::string myType;

    unsigned int myNoLanes;

    SUMOReal myZuschlag1, myZuschlag2;

    NIVissimClosedLanesVector myClosedLanes;

    ConnectionClusters myConnectionClusters;

    IntVector myIncomingConnections;

    IntVector myOutgoingConnections;

    DoubleVector myDistrictConnections;

    IntVector myPatchedSpeeds;

    std::vector<SUMOReal> myLaneSpeeds;

    std::vector<NIVissimEdge*> myToTreatAsSame;

    bool myAmWithinJunction;

private:
    typedef std::map<int, NIVissimEdge*> DictType;

    static DictType myDict;

    static int myMaxID;

    static std::vector<std::string> myLanesWithMissingSpeeds;

};


#endif

/****************************************************************************/