GNEGeometry.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2021 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
/****************************************************************************/
// File for geometry classes and functions
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/common/MsgHandler.h>
#include <utils/common/Parameterised.h>
#include <utils/common/ToString.h>
#include <utils/common/UtilExceptions.h>
#include <utils/geom/PositionVector.h>
#include <utils/gui/globjects/GUIGlObjectTypes.h>
#include <utils/gui/images/GUIIcons.h>
#include <utils/gui/settings/GUIVisualizationSettings.h>
#include <utils/xml/SUMOSAXAttributes.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
#include "GNEReferenceCounter.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class GNEAttributeCarrier;
class GNELane;
class GNEEdge;
class GNEAdditional;
class GNEDemandElement;
class GNEJunction;
class GNEViewNet;
class GNEHierarchicalElement;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
struct GNEGeometry {
 
    class Geometry {
 
    public:
        Geometry();
 
        Geometry(const PositionVector& shape);
 
        Geometry(const PositionVector& shape, const std::vector<double>& shapeRotations, const std::vector<double>& shapeLengths);
 
        void updateGeometry(const PositionVector& shape);
 
        void updateGeometry(const PositionVector& shape, const double posOverShape, const double lateralOffset);
 
        void updateGeometry(const PositionVector& shape, double starPosOverShape, double endPosOverShape, const double lateralOffset);
 
        void updateGeometry(const PositionVector& shape, double beginTrimPosition, double endTrimPosition,
                            const Position& extraFirstPosition, const Position& extraLastPosition);
 
        void updateSinglePosGeometry(const Position& position, const double rotation);
 
        void scaleGeometry(const double scale);
 
        const PositionVector& getShape() const;
 
        const std::vector<double>& getShapeRotations() const;
 
        const std::vector<double>& getShapeLengths() const;
 
    protected:
        void clearGeometry();
 
        void calculateShapeRotationsAndLengths();
 
        PositionVector myShape;
 
        std::vector<double> myShapeRotations;
 
        std::vector<double> myShapeLengths;
    };
 
    enum class DottedContourType {
        INSPECT,
        FRONT,
        MOVE,
        GREEN,
        MAGENTA
    };
 
    class DottedGeometryColor {
 
    public:
        DottedGeometryColor(const GUIVisualizationSettings& settings);
 
        const RGBColor getColor(DottedContourType type);
 
        void changeColor();
 
        void reset();
 
    private:
        const GUIVisualizationSettings& mySettings;
 
        bool myColorFlag;
 
        DottedGeometryColor& operator=(const DottedGeometryColor& other) = delete;
    };
 
    class DottedGeometry {
 
    public:
        struct Segment {
            Segment();
 
            Segment(PositionVector newShape);
 
            PositionVector shape;
 
            std::vector<double> rotations;
 
            std::vector<double> lengths;
 
            double offset;
        };
 
        DottedGeometry();
 
        DottedGeometry(const GUIVisualizationSettings& s, PositionVector shape, const bool closeShape);
 
        DottedGeometry(const GUIVisualizationSettings& s,
                       const DottedGeometry& topDottedGeometry, const bool drawFirstExtrem,
                       const DottedGeometry& botDottedGeometry, const bool drawLastExtrem);
 
        void updateDottedGeometry(const GUIVisualizationSettings& s, const GNELane* lane);
 
        void updateDottedGeometry(const GUIVisualizationSettings& s, PositionVector shape, const bool closeShape);
 
        void drawDottedGeometry(DottedGeometryColor& dottedGeometryColor, GNEGeometry::DottedContourType type, const double customWidth = -1) const;
 
        void moveShapeToSide(const double value);
 
        double getWidth() const;
 
        void setWidth(const double width);
 
        void invertOffset();
 
    private:
        void calculateShapeRotationsAndLengths();
 
        double myWidth;
 
        std::vector<DottedGeometry::Segment> myDottedGeometrySegments;
 
        DottedGeometry& operator=(const DottedGeometry& other) = delete;
    };
 
    class Lane2laneConnection {
 
    public:
        Lane2laneConnection(const GNELane* fromLane);
 
        void updateLane2laneConnection();
 
        bool exist(const GNELane* toLane) const;
 
        const GNEGeometry::Geometry& getLane2laneGeometry(const GNELane* toLane) const;
 
    protected:
        const GNELane* myFromLane;
 
        std::map<const GNELane*, GNEGeometry::Geometry> myConnectionsMap;
 
    private:
        Lane2laneConnection();
 
        Lane2laneConnection& operator=(const Lane2laneConnection& other) = delete;
    };
 
    static double calculateRotation(const Position& first, const Position& second);
 
    static double calculateLength(const Position& first, const Position& second);
 
    static void adjustStartPosGeometricPath(double& startPos, const GNELane* startLane, double& endPos, const GNELane* endLane);
 
    static void drawLaneGeometry(const GNEViewNet* viewNet, const PositionVector& shape, const std::vector<double>& rotations,
                                 const std::vector<double>& lengths, const std::vector<RGBColor>& colors, double width, const bool onlyContour = false);
 
    static void drawGeometry(const GNEViewNet* viewNet, const Geometry& geometry, const double width);
 
    static void drawContourGeometry(const Geometry& geometry, const double width, const bool drawExtremes = false);
 
    static void drawGeometryPoints(const GUIVisualizationSettings& s, const GNEViewNet* viewNet, const PositionVector& shape,
                                   const RGBColor& geometryPointColor, const RGBColor& textColor, const double radius, const double exaggeration);
 
    static void drawMovingHint(const GUIVisualizationSettings& s, const GNEViewNet* viewNet, const PositionVector& shape,
                               const RGBColor& hintColor, const double radius, const double exaggeration);
 
    static void drawDottedContourEdge(const DottedContourType type, const GUIVisualizationSettings& s, const GNEEdge* edge, 
                                      const bool drawFrontExtreme, const bool drawBackExtreme);
 
    static void drawDottedContourClosedShape(const DottedContourType type, const GUIVisualizationSettings& s, const PositionVector& shape, 
                                             const double exaggeration, const double lineWidth = -1);
 
    static void drawDottedContourShape(const DottedContourType type, const GUIVisualizationSettings& s, const PositionVector& shape, 
                                       const double width, const double exaggeration, const bool drawFirstExtrem, const bool drawLastExtrem, 
                                       const double lineWidth = -1);
 
    static void drawDottedContourCircle(const DottedContourType type, const GUIVisualizationSettings& s, const Position& pos, 
                                        const double radius, const double exaggeration);
 
    static void drawDottedSquaredShape(const DottedContourType type, const GUIVisualizationSettings& s, const Position& pos,
                                       const double width, const double height, const double offsetX, const double offsetY, 
                                       const double rot, const double exaggeration);
 
    static void drawParentLine(const GUIVisualizationSettings& s, const Position &parent, const Position& child, const RGBColor &color, const bool drawEntire);
    
    static void drawChildLine(const GUIVisualizationSettings& s, const Position &child, const Position& parent, const RGBColor &color, const bool drawEntire);
 
    static PositionVector getVertexCircleAroundPosition(const Position& pos, const double width, const int steps = 8);
 
    static void rotateOverLane(const double rot);
 
private:
    static PositionVector myCircleCoords;
 
    static int angleLookup(const double angleDeg);
};