NBContHelper.h

Go to the documentation of this file.

/****************************************************************************/
// Some methods for traversing lists of edges
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO 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 3 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 double getMaxSpeed(const EdgeVector& edges);

    static double getMinSpeed(const EdgeVector& edges);

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


    class relative_outgoing_edge_sorter {
    public:
        explicit relative_outgoing_edge_sorter(NBEdge* e) : myEdge(e) {}

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

    private:
        NBEdge* myEdge;
    };


    class straightness_sorter {
    public:
        explicit straightness_sorter(const NBNode* n, const NBEdge* e):
            myRefIncoming(e->getToNode() == n) {
            if (myRefIncoming) {
                myReferencePos = e->getLaneShape(0).back();
                myReferenceAngle = e->getShapeEndAngle();
            } else {
                myReferencePos = e->getLaneShape(0).front();
                myReferenceAngle = e->getShapeStartAngle();
            }
        }

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

    private:
        bool myRefIncoming;
        Position myReferencePos;
        double myReferenceAngle;
    };


    class relative_incoming_edge_sorter {
    public:
        explicit relative_incoming_edge_sorter(NBEdge* e) : myEdge(e) {}

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

    private:
        NBEdge* myEdge;
    };


    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->getNumLanes() > e2->getNumLanes();
        }
    };

    // ---------------------------

    class edge_opposite_direction_sorter {
    public:
        explicit edge_opposite_direction_sorter(const NBEdge* const e, const NBNode* const n, bool regardPriority) :
            myNode(n),
            myEdge(e),
            myRegardPriority(regardPriority) {
            myAngle = getEdgeAngleAt(e, n);
        }

        int operator()(NBEdge* e1, NBEdge* e2) const {
            if (!myRegardPriority || e1->getPriority() == e2->getPriority() || e1 == myEdge || e2 == myEdge) {
                return getDiff(e1) > getDiff(e2);
            } else {
                return e1->getPriority() > e2->getPriority();
            }
        }

    protected:
        double getDiff(const NBEdge* const e) const {
            return fabs(GeomHelper::angleDiff(getEdgeAngleAt(e, myNode), myAngle));
        }

        double getEdgeAngleAt(const NBEdge* const e, const NBNode* const n) const {
            if (e->getFromNode() == n) {
                return e->getGeometry().angleAt2D(0);
            } else {
                return e->getGeometry()[-1].angleTo2D(e->getGeometry()[-2]);
            }
        }

    private:

        const NBNode* const myNode;

        const NBEdge* const myEdge;

        double myAngle;

        bool myRegardPriority;

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

    };

    // ---------------------------

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

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

    private:
        double 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 double maxSpeed(const EdgeVector& ev);

    class same_connection_edge_sorter {
    public:
        explicit same_connection_edge_sorter() { }

        int operator()(NBEdge* e1, NBEdge* e2) const {
            std::pair<double, double> mm1 = getMinMaxRelAngles(e1);
            std::pair<double, double> 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<double, double> getMinMaxRelAngles(NBEdge* e) const {
            double min = 360;
            double max = 360;
            const EdgeVector& ev = e->getConnectedEdges();
            for (EdgeVector::const_iterator i = ev.begin(); i != ev.end(); ++i) {
                double angle = NBHelpers::normRelAngle(
                                   e->getTotalAngle(), (*i)->getTotalAngle());
                if (min == 360 || min > angle) {
                    min = angle;
                }
                if (max == 360 || max < angle) {
                    max = angle;
                }
            }
            return std::pair<double, double>(min, max);
        }
    };


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

    class opposite_finder {
    public:
        opposite_finder(NBEdge* edge)
            : myReferenceEdge(edge) { }

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

    private:
        NBEdge* myReferenceEdge;

    };

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

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

    private:
        const NBNode* myNode;
    };

};


#endif

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