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 2001-2010 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/Position2DVector.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 Position2DVector &geom,
                 const NIVissimClosedLanesVector &clv);

    ~NIVissimEdge();

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

    void addIncomingConnection(int id);

    void addOutgoingConnection(int id);

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

    Position2D getBegin2D() const;

    Position2D 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 Position2DVector &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 Position2D &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

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