Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file NIVissimAbstractEdge.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date Sept 2002
19 : ///
20 : // -------------------
21 : /****************************************************************************/
22 : #include <config.h>
23 :
24 :
25 : #include <map>
26 : #include <cassert>
27 : #include <utils/common/MsgHandler.h>
28 : #include <utils/common/ToString.h>
29 : #include <utils/geom/GeomHelper.h>
30 : #include <utils/geom/GeoConvHelper.h>
31 : #include <netbuild/NBNetBuilder.h>
32 : #include "NIVissimAbstractEdge.h"
33 :
34 :
35 : NIVissimAbstractEdge::DictType NIVissimAbstractEdge::myDict;
36 :
37 1610 : NIVissimAbstractEdge::NIVissimAbstractEdge(int id,
38 1610 : const PositionVector& geom)
39 1610 : : myID(id), myNode(-1) {
40 : // convert/publicate geometry
41 8043 : for (PositionVector::const_iterator i = geom.begin(); i != geom.end(); ++i) {
42 6433 : Position p = *i;
43 6433 : if (!NBNetBuilder::transformCoordinate(p)) {
44 0 : WRITE_WARNINGF(TL("Unable to project coordinates for edge '%'."), toString(id));
45 : }
46 6433 : myGeom.push_back_noDoublePos(p);
47 : }
48 : //
49 1610 : dictionary(id, this);
50 1610 : }
51 :
52 :
53 1610 : NIVissimAbstractEdge::~NIVissimAbstractEdge() {}
54 :
55 :
56 : bool
57 1610 : NIVissimAbstractEdge::dictionary(int id, NIVissimAbstractEdge* e) {
58 : DictType::iterator i = myDict.find(id);
59 1610 : if (i == myDict.end()) {
60 1610 : myDict[id] = e;
61 1610 : return true;
62 : }
63 : return false;
64 : }
65 :
66 :
67 : NIVissimAbstractEdge*
68 13148 : NIVissimAbstractEdge::dictionary(int id) {
69 : DictType::iterator i = myDict.find(id);
70 13148 : if (i == myDict.end()) {
71 : return nullptr;
72 : }
73 13148 : return (*i).second;
74 : }
75 :
76 :
77 :
78 : Position
79 9042 : NIVissimAbstractEdge::getGeomPosition(double pos) const {
80 9042 : if (myGeom.length() > pos) {
81 8993 : return myGeom.positionAtOffset(pos);
82 49 : } else if (myGeom.length() == pos) {
83 0 : return myGeom[-1];
84 : } else {
85 : PositionVector g(myGeom);
86 49 : const double amount = pos - myGeom.length();
87 49 : g.extrapolate(amount * 2);
88 49 : return g.positionAtOffset(pos + amount * 2);
89 49 : }
90 : }
91 :
92 :
93 : void
94 0 : NIVissimAbstractEdge::splitAndAssignToNodes() {
95 0 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
96 0 : NIVissimAbstractEdge* e = (*i).second;
97 0 : e->splitAssigning();
98 : }
99 0 : }
100 :
101 : void
102 0 : NIVissimAbstractEdge::splitAssigning() {}
103 :
104 :
105 :
106 :
107 :
108 : bool
109 1805 : NIVissimAbstractEdge::crossesEdge(NIVissimAbstractEdge* c) const {
110 1805 : return myGeom.intersects(c->myGeom);
111 : }
112 :
113 :
114 : Position
115 806 : NIVissimAbstractEdge::crossesEdgeAtPoint(NIVissimAbstractEdge* c) const {
116 806 : return myGeom.intersectionPosition2D(c->myGeom);
117 : }
118 :
119 :
120 : std::vector<int>
121 0 : NIVissimAbstractEdge::getWithin(const AbstractPoly& p, double offset) {
122 : std::vector<int> ret;
123 0 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
124 0 : NIVissimAbstractEdge* e = (*i).second;
125 0 : if (e->overlapsWith(p, offset)) {
126 0 : ret.push_back(e->myID);
127 : }
128 : }
129 0 : return ret;
130 0 : }
131 :
132 :
133 : bool
134 0 : NIVissimAbstractEdge::overlapsWith(const AbstractPoly& p, double offset) const {
135 0 : return myGeom.overlapsWith(p, offset);
136 : }
137 :
138 :
139 : bool
140 1854 : NIVissimAbstractEdge::hasNodeCluster() const {
141 1854 : return myNode != -1;
142 : }
143 :
144 :
145 : int
146 196523 : NIVissimAbstractEdge::getID() const {
147 196523 : return myID;
148 : }
149 :
150 : void
151 36 : NIVissimAbstractEdge::clearDict() {
152 1646 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); i++) {
153 1610 : delete (*i).second;
154 : }
155 : myDict.clear();
156 36 : }
157 :
158 :
159 : const PositionVector&
160 125991 : NIVissimAbstractEdge::getGeometry() const {
161 125991 : return myGeom;
162 : }
163 :
164 :
165 : void
166 830 : NIVissimAbstractEdge::addDisturbance(int disturbance) {
167 830 : myDisturbances.push_back(disturbance);
168 830 : }
169 :
170 :
171 : const std::vector<int>&
172 4977 : NIVissimAbstractEdge::getDisturbances() const {
173 4977 : return myDisturbances;
174 : }
175 :
176 :
177 : /****************************************************************************/
|
