Eclipse SUMO - Simulation of Urban MObility
PositionVector.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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/****************************************************************************/
20// A list of positions
21/****************************************************************************/
22#pragma once
23#include <config.h>
24
25#include <vector>
26#include <limits>
27#include "AbstractPoly.h"
28
29
30// ===========================================================================
31// class declarations
32// ===========================================================================
33
34class Boundary;
35
36// ===========================================================================
37// class definitions
38// ===========================================================================
43class PositionVector : public AbstractPoly, private std::vector<Position> {
44
45private:
47 typedef std::vector<Position> vp;
48
49public:
52
55 PositionVector(const std::vector<Position>& v);
56
60 PositionVector(const std::vector<Position>::const_iterator beg, const std::vector<Position>::const_iterator end);
61
65 PositionVector(const Position& p1, const Position& p2);
66
69
71 static const PositionVector EMPTY;
72
76 using vp::iterator;
77
79 using vp::const_iterator;
80
82 using vp::const_reference;
83
85 using vp::value_type;
86
88 using vp::begin;
89
91 using vp::end;
92
94 using vp::push_back;
95
97 using vp::pop_back;
98
100 using vp::clear;
101
103 using vp::size;
104
106 using vp::front;
107
109 using vp::back;
110
112 using vp::reference;
113
115 using vp::erase;
116
118 using vp::insert;
120
123 bool around(const Position& p, double offset = 0) const;
124
127 bool overlapsWith(const AbstractPoly& poly, double offset = 0) const;
128
130 double getOverlapWith(const PositionVector& poly, double zThreshold) const;
131
133 bool intersects(const Position& p1, const Position& p2) const;
134
136 bool intersects(const PositionVector& v1) const;
137
139 Position intersectionPosition2D(const Position& p1, const Position& p2, const double withinDist = 0.) const;
140
142 std::vector<double> intersectsAtLengths2D(const PositionVector& other) const;
143
145 std::vector<double> intersectsAtLengths2D(const Position& lp1, const Position& lp2) const;
146
149
151 void closePolygon();
152
155 const Position& operator[](int index) const;
156
159 Position& operator[](int index);
160
162 Position positionAtOffset(double pos, double lateralOffset = 0) const;
163
165 Position positionAtOffset2D(double pos, double lateralOffset = 0) const;
166
168 double rotationAtOffset(double pos) const;
169
171 double rotationDegreeAtOffset(double pos) const;
172
174 double slopeDegreeAtOffset(double pos) const;
175
177 static Position positionAtOffset(const Position& p1, const Position& p2, double pos, double lateralOffset = 0.);
178
180 static Position positionAtOffset2D(const Position& p1, const Position& p2, double pos, double lateralOffset = 0.);
181
183 Boundary getBoxBoundary() const;
184
188
190 Position getCentroid() const;
191
193 void scaleRelative(double factor);
194
196 void scaleAbsolute(double offset);
197
199 Position getLineCenter() const;
200
202 double length() const;
203
205 double length2D() const;
206
208 double area() const;
209
211 bool partialWithin(const AbstractPoly& poly, double offset = 0) const;
212
214 std::pair<PositionVector, PositionVector> splitAt(double where, bool use2D = false) const;
215
217 friend std::ostream& operator<<(std::ostream& os, const PositionVector& geom);
218
220 bool crosses(const Position& p1, const Position& p2) const;
221
223 void add(double xoff, double yoff, double zoff);
224
226 void add(const Position& offset);
227
229 void sub(const Position& offset);
230
232 PositionVector added(const Position& offset) const;
233
235 void mirrorX();
236
238 void rotate2D(double angle);
239
241 void append(const PositionVector& v, double sameThreshold = 2.0);
242
244 void prepend(const PositionVector& v, double sameThreshold = 2.0);
245
247 PositionVector getSubpart(double beginOffset, double endOffset) const;
248
250 PositionVector getSubpart2D(double beginOffset, double endOffset) const;
251
253 PositionVector getSubpartByIndex(int beginIndex, int count) const;
254
256 void sortAsPolyCWByAngle();
257
259 void sortByIncreasingXY();
260
262 void extrapolate(const double val, const bool onlyFirst = false, const bool onlyLast = false);
263
265 void extrapolate2D(const double val, const bool onlyFirst = false);
266
268 PositionVector reverse() const;
269
271 static Position sideOffset(const Position& beg, const Position& end, const double amount);
272
274 void move2side(double amount, double maxExtension = 100);
275
277 void move2sideCustom(std::vector<double> amount, double maxExtension = 100);
278
280 double angleAt2D(int pos) const;
281
287 int insertAtClosest(const Position& p, bool interpolateZ);
288
290 int removeClosest(const Position& p);
291
293 bool operator==(const PositionVector& v2) const;
294
296 bool operator!=(const PositionVector& v2) const;
297
299 PositionVector operator-(const PositionVector& v2) const;
300
302 PositionVector operator+(const PositionVector& v2) const;
303
306 public:
309
311 int operator()(const Position& p1, const Position& p2) const;
312 };
313
316 public:
318 explicit increasing_x_y_sorter();
319
321 int operator()(const Position& p1, const Position& p2) const;
322 };
323
326 double isLeft(const Position& P0, const Position& P1, const Position& P2) const;
327
329 double beginEndAngle() const;
330
332 double nearest_offset_to_point2D(const Position& p, bool perpendicular = true) const;
333
335 double nearest_offset_to_point25D(const Position& p, bool perpendicular = true) const;
336
344 Position transformToVectorCoordinates(const Position& p, bool extend = false) const;
345
346 /* @brief index of the closest position to p
347 * @in twoD whether all positions should be projected onto the plan
348 @note: may only be called for a non-empty vector
349 */
350 int indexOfClosest(const Position& p, bool twoD = false) const;
351
354 std::vector<double> distances(const PositionVector& s, bool perpendicular = false) const;
355
357 double distance2D(const Position& p, bool perpendicular = false) const;
358
360 void push_front(const Position& p);
361
363 void pop_front();
364
366 void push_back_noDoublePos(const Position& p);
367
369 void push_front_noDoublePos(const Position& p);
370
372 void insert_noDoublePos(const std::vector<Position>::iterator& at, const Position& p);
373
375 bool isClosed() const;
376
378 bool isNAN() const;
379
384 void removeDoublePoints(double minDist = POSITION_EPS, bool assertLength = false, int beginOffset = 0, int endOffset = 0, bool resample = false);
385
387 bool hasElevation() const;
388
391
399 PositionVector getOrthogonal(const Position& p, double extend, bool before, double length = 1.0, double deg = 90) const;
400
402 PositionVector smoothedZFront(double dist = std::numeric_limits<double>::max()) const;
403
405 PositionVector interpolateZ(double zStart, double zEnd) const;
406
411 PositionVector resample(double maxLength, const bool adjustEnd) const;
412
414 double offsetAtIndex2D(int index) const;
415
416 /* @brief return the maximum grade of all segments as a fraction of zRange/length2D
417 * @param[out] maxJump The maximum vertical jump (with grade infinity)
418 */
419 double getMaxGrade(double& maxJump) const;
420
422 PositionVector bezier(int numPoints);
423
424 static double localAngle(const Position& from, const Position& pos, const Position& to);
425
426private:
428 static bool intersects(const Position& p11, const Position& p12, const Position& p21, const Position& p22, const double withinDist = 0., double* x = 0, double* y = 0, double* mu = 0);
429};
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
int operator()(const Position &p1, const Position &p2) const
comparing operation for sort
clase for increasing Sorter
int operator()(const Position &p1, const Position &p2) const
comparing operation
A list of positions.
PositionVector operator-(const PositionVector &v2) const
substracts two vectors (requires vectors of the same length)
void scaleAbsolute(double offset)
enlarges/shrinks the polygon by an absolute offset based at the centroid
double length2D() const
Returns the length.
void append(const PositionVector &v, double sameThreshold=2.0)
bool overlapsWith(const AbstractPoly &poly, double offset=0) const
Returns the information whether the given polygon overlaps with this.
PositionVector added(const Position &offset) const
double isLeft(const Position &P0, const Position &P1, const Position &P2) const
get left
double beginEndAngle() const
returns the angle in radians of the line connecting the first and the last position
double length() const
Returns the length.
void move2sideCustom(std::vector< double > amount, double maxExtension=100)
move position vector to side using a custom offset for each geometry point
void sortAsPolyCWByAngle()
sort as polygon CW by angle
PositionVector simplified() const
return the same shape with intermediate colinear points removed
void rotate2D(double angle)
PositionVector()
Constructor. Creates an empty position vector.
Position getPolygonCenter() const
Returns the arithmetic of all corner points.
Position intersectionPosition2D(const Position &p1, const Position &p2, const double withinDist=0.) const
Returns the position of the intersection.
const Position & operator[](int index) const
returns the constant position at the given index, negative indices are interpreted python style
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
std::vector< Position > vp
vector of position
void push_front_noDoublePos(const Position &p)
insert in front a non double position
bool operator!=(const PositionVector &v2) const
comparing operation
PositionVector resample(double maxLength, const bool adjustEnd) const
resample shape (i.e. transform to segments, equal spacing)
void sortByIncreasingXY()
sort by increasing X-Y Positions
double rotationDegreeAtOffset(double pos) const
Returns the rotation at the given length.
bool isNAN() const
check if PositionVector is NAN
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
void add(double xoff, double yoff, double zoff)
void closePolygon()
ensures that the last position equals the first
static Position sideOffset(const Position &beg, const Position &end, const double amount)
get a side position of position vector using a offset
std::vector< double > intersectsAtLengths2D(const PositionVector &other) const
For all intersections between this vector and other, return the 2D-length of the subvector from this ...
friend std::ostream & operator<<(std::ostream &os, const PositionVector &geom)
double distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector)
void prepend(const PositionVector &v, double sameThreshold=2.0)
double nearest_offset_to_point2D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D
std::vector< double > distances(const PositionVector &s, bool perpendicular=false) const
distances of all my points to s and all of s points to myself
PositionVector getOrthogonal(const Position &p, double extend, bool before, double length=1.0, double deg=90) const
return orthogonal through p (extending this vector if necessary)
int indexOfClosest(const Position &p, bool twoD=false) const
std::pair< PositionVector, PositionVector > splitAt(double where, bool use2D=false) const
Returns the two lists made when this list vector is splitted at the given point.
void move2side(double amount, double maxExtension=100)
move position vector to side using certain ammount
bool crosses(const Position &p1, const Position &p2) const
Returns whether the AbstractPoly crosses the given line.
PositionVector getSubpart2D(double beginOffset, double endOffset) const
get subpart of a position vector in two dimensions (Z is ignored)
PositionVector interpolateZ(double zStart, double zEnd) const
returned vector that varies z smoothly over its length
Boundary getBoxBoundary() const
Returns a boundary enclosing this list of lines.
double offsetAtIndex2D(int index) const
return the offset at the given index
PositionVector smoothedZFront(double dist=std::numeric_limits< double >::max()) const
returned vector that is smoothed at the front (within dist)
double angleAt2D(int pos) const
get angle in certain position of position vector
void insert_noDoublePos(const std::vector< Position >::iterator &at, const Position &p)
insert in front a non double position
double slopeDegreeAtOffset(double pos) const
Returns the slope at the given length.
bool hasElevation() const
return whether two positions differ in z-coordinate
static const PositionVector EMPTY
empty Vector
void extrapolate(const double val, const bool onlyFirst=false, const bool onlyLast=false)
extrapolate position vector
PositionVector bezier(int numPoints)
return a bezier interpolation
Position getLineCenter() const
get line center
Position getCentroid() const
Returns the centroid (closes the polygon if unclosed)
double getOverlapWith(const PositionVector &poly, double zThreshold) const
Returns the maximum overlaps between this and the given polygon (when not separated by at least zThre...
PositionVector operator+(const PositionVector &v2) const
adds two vectors (requires vectors of the same length)
void extrapolate2D(const double val, const bool onlyFirst=false)
extrapolate position vector in two dimensions (Z is ignored)
int insertAtClosest(const Position &p, bool interpolateZ)
inserts p between the two closest positions
void push_front(const Position &p)
insert in front a Position
void scaleRelative(double factor)
enlarges/shrinks the polygon by a factor based at the centroid
void push_back_noDoublePos(const Position &p)
insert in back a non double position
void removeDoublePoints(double minDist=POSITION_EPS, bool assertLength=false, int beginOffset=0, int endOffset=0, bool resample=false)
Removes positions if too near.
bool partialWithin(const AbstractPoly &poly, double offset=0) const
Returns the information whether this polygon lies partially within the given polygon.
double getMaxGrade(double &maxJump) const
double area() const
Returns the area (0 for non-closed)
bool isClosed() const
check if PositionVector is closed
void pop_front()
pop first Position
double nearest_offset_to_point25D(const Position &p, bool perpendicular=true) const
return the nearest offest to point 2D projected onto the 3D geometry
int removeClosest(const Position &p)
removes the point closest to p and return the removal index
static double localAngle(const Position &from, const Position &pos, const Position &to)
bool intersects(const Position &p1, const Position &p2) const
Returns the information whether this list of points interesects the given line.
PositionVector reverse() const
reverse position vector
PositionVector getSubpartByIndex(int beginIndex, int count) const
get subpart of a position vector using index and a cout
Position positionAtOffset2D(double pos, double lateralOffset=0) const
Returns the position at the given length.
bool operator==(const PositionVector &v2) const
comparing operation
void sub(const Position &offset)
PositionVector getSubpart(double beginOffset, double endOffset) const
get subpart of a position vector
~PositionVector()
Destructor.
bool around(const Position &p, double offset=0) const
Returns the information whether the position vector describes a polygon lying around the given point.
Position transformToVectorCoordinates(const Position &p, bool extend=false) const
return position p within the length-wise coordinate system defined by this position vector....