NBContHelper.h

Go to the documentation of this file.

/****************************************************************************/
// Some methods for traversing lists of edges
/****************************************************************************/
// 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 NBContHelper_h
#define NBContHelper_h


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

#include <vector>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cassert>
#include "NBHelpers.h"
#include "NBCont.h"
#include "NBEdge.h"
#include "NBNode.h"
#include <utils/common/StdDefs.h>
#include <utils/geom/GeomHelper.h>


// ===========================================================================
// class definitions
// ===========================================================================
class NBContHelper {
public:
    static void nextCW(const EdgeVector * edges,
                       EdgeVector::const_iterator &from);

    static void nextCCW(const EdgeVector * edges,
                        EdgeVector::const_iterator &from);

    static SUMOReal getMaxSpeed(const EdgeVector &edges);

    static SUMOReal getMinSpeed(const EdgeVector &edges);

    static std::ostream &out(std::ostream &os, const std::vector<bool> &v);

    class edge_by_junction_angle_sorter {
    public:
        explicit edge_by_junction_angle_sorter(NBNode *n) : myNode(n) {}

        int operator()(NBEdge *e1, NBEdge *e2) const;

    private:
        SUMOReal getConvAngle(NBEdge *e) const;

    private:
        NBNode *myNode;

    };

    class relative_edge_sorter {
    public:
        explicit relative_edge_sorter(NBEdge *e, NBNode *n)
                : myEdge(e), myNode(n) {}

    public:
        int operator()(NBEdge *e1, NBEdge *e2) const {
            if (e1==0||e2==0) {
                return -1;
            }
            SUMOReal relAngle1 = NBHelpers::normRelAngle(
                                     myEdge->getAngle(), e1->getAngle());
            SUMOReal relAngle2 = NBHelpers::normRelAngle(
                                     myEdge->getAngle(), e2->getAngle());
            return relAngle1 > relAngle2;
        }

    private:
        NBEdge *myEdge;

        NBNode *myNode;

    };


    class edge_by_priority_sorter {
    public:
        int operator()(NBEdge *e1, NBEdge *e2) const {
            if (e1->getPriority()!=e2->getPriority()) {
                return e1->getPriority() > e2->getPriority();
            }
            if (e1->getSpeed()!=e2->getSpeed()) {
                return e1->getSpeed() > e2->getSpeed();
            }
            return e1->getNoLanes() > e2->getNoLanes();
        }
    };

    class edge_opposite_direction_sorter {
    public:
        explicit edge_opposite_direction_sorter(NBEdge *e)
                : myAngle(e->getAngle()), myEdge(e) {}

    public:
        int operator()(NBEdge *e1, NBEdge *e2) const {
            SUMOReal d1 = getDiff(e1);
            SUMOReal d2 = getDiff(e2);
            return d1 < d2;
        }

        SUMOReal getDiff(NBEdge *e) const {
            SUMOReal d = e->getAngle()+180;
            if (d>=360) {
                d -= 360;
            }
            return GeomHelper::getMinAngleDiff(d, myAngle);
        }

    private:
        SUMOReal myAngle;

        NBEdge *myEdge;

    };

    class edge_similar_direction_sorter {
    public:
        explicit edge_similar_direction_sorter(NBEdge *e)
                : myAngle(e->getAngle()) {}

        int operator()(NBEdge *e1, NBEdge *e2) const {
            SUMOReal d1 = GeomHelper::getMinAngleDiff(e1->getAngle(), myAngle);
            SUMOReal d2 = GeomHelper::getMinAngleDiff(e2->getAngle(), myAngle);
            return d1 < d2;
        }

    private:
        SUMOReal myAngle;
    };


    class node_with_incoming_finder {
    public:
        node_with_incoming_finder(const NBEdge * const e);

        bool operator()(const NBNode * const n) const;

    private:
        const NBEdge * const myEdge;

    private:
        node_with_incoming_finder &operator=(const node_with_incoming_finder &s);

    };


    class node_with_outgoing_finder {
    public:
        node_with_outgoing_finder(const NBEdge * const e);

        bool operator()(const NBNode * const n) const;

    private:
        const NBEdge * const myEdge;

    private:
        node_with_outgoing_finder &operator=(const node_with_outgoing_finder &s);

    };




    class edge_with_destination_finder {
    public:
        edge_with_destination_finder(NBNode *dest);

        bool operator()(NBEdge *e) const;

    private:
        NBNode *myDestinationNode;

    private:
        edge_with_destination_finder &operator=(const edge_with_destination_finder &s);

    };


    static NBEdge *findConnectingEdge(const EdgeVector &edges,
                                      NBNode *from, NBNode *to);


    static SUMOReal maxSpeed(const EdgeVector &ev);

    class same_connection_edge_sorter {
    public:
        explicit same_connection_edge_sorter() { }

        int operator()(NBEdge *e1, NBEdge *e2) const {
            std::pair<SUMOReal, SUMOReal> mm1 = getMinMaxRelAngles(e1);
            std::pair<SUMOReal, SUMOReal> mm2 = getMinMaxRelAngles(e2);
            if (mm1.first==mm2.first && mm1.second==mm2.second) {
                // ok, let's simply sort them arbitrarily
                return e1->getID() < e2->getID();
            }

            assert(
                (mm1.first<=mm2.first&&mm1.second<=mm2.second)
                ||
                (mm1.first>=mm2.first&&mm1.second>=mm2.second));
            return (mm1.first>=mm2.first&&mm1.second>=mm2.second);
        }

        std::pair<SUMOReal, SUMOReal> getMinMaxRelAngles(NBEdge *e) const {
            SUMOReal min = 360;
            SUMOReal max = 360;
            const EdgeVector &ev = e->getConnectedEdges();
            for (EdgeVector::const_iterator i=ev.begin(); i!=ev.end(); ++i) {
                SUMOReal angle = NBHelpers::normRelAngle(
                                     e->getAngle(), (*i)->getAngle());
                if (min==360||min>angle) {
                    min = angle;
                }
                if (max==360||max<angle) {
                    max = angle;
                }
            }
            return std::pair<SUMOReal, SUMOReal>(min, max);
        }
    };


    friend std::ostream &operator<<(std::ostream &os, const EdgeVector &ev);

    class opposite_finder {
    public:
        opposite_finder(NBEdge *edge, const NBNode *n)
                : myReferenceEdge(edge), myAtNode(n) { }

        bool operator()(NBEdge *e) const {
            return e->isTurningDirectionAt(myAtNode, myReferenceEdge)||
                   myReferenceEdge->isTurningDirectionAt(myAtNode, e);
        }

    private:
        NBEdge *myReferenceEdge;
        const NBNode *myAtNode;

    };


};


#endif

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