Eclipse SUMO - Simulation of Urban MObility
Position.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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
18 // A position in the 2D- or 3D-world
19 /****************************************************************************/
20 #ifndef Position_h
21 #define Position_h
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <iostream>
28 #include <cmath>
29 
30 #include <config.h>
31 
32 // ===========================================================================
33 // class definitions
34 // ===========================================================================
39 class Position {
40 public:
43  myX(0.0), myY(0.0), myZ(0.0) { }
44 
46  Position(double x, double y) :
47  myX(x), myY(y), myZ(0) { }
48 
50  Position(double x, double y, double z) :
51  myX(x), myY(y), myZ(z) { }
52 
54  ~Position() { }
55 
57  inline double x() const {
58  return myX;
59  }
60 
62  inline double y() const {
63  return myY;
64  }
65 
67  inline double z() const {
68  return myZ;
69  }
70 
72  void setx(double x) {
73  myX = x;
74  }
75 
77  void sety(double y) {
78  myY = y;
79  }
80 
82  void setz(double z) {
83  myZ = z;
84  }
85 
87  void set(double x, double y) {
88  myX = x;
89  myY = y;
90  }
91 
93  void set(double x, double y, double z) {
94  myX = x;
95  myY = y;
96  myZ = z;
97  }
98 
100  void set(const Position& pos) {
101  myX = pos.myX;
102  myY = pos.myY;
103  myZ = pos.myZ;
104  }
105 
107  void mul(double val) {
108  myX *= val;
109  myY *= val;
110  myZ *= val;
111  }
112 
114  void mul(double mx, double my) {
115  myX *= mx;
116  myY *= my;
117  }
118 
120  void mul(double mx, double my, double mz) {
121  myX *= mx;
122  myY *= my;
123  myZ *= mz;
124  }
125 
127  void add(const Position& pos) {
128  myX += pos.myX;
129  myY += pos.myY;
130  myZ += pos.myZ;
131  }
132 
134  void add(double dx, double dy) {
135  myX += dx;
136  myY += dy;
137  }
138 
140  void add(double dx, double dy, double dz) {
141  myX += dx;
142  myY += dy;
143  myZ += dz;
144  }
145 
147  void sub(double dx, double dy) {
148  myX -= dx;
149  myY -= dy;
150  }
151 
153  void sub(double dx, double dy, double dz) {
154  myX -= dx;
155  myY -= dy;
156  myZ -= dz;
157  }
158 
160  void sub(const Position& pos) {
161  myX -= pos.myX;
162  myY -= pos.myY;
163  myZ -= pos.myZ;
164  }
165 
167  void norm2d() {
168  double val = sqrt(myX * myX + myY * myY);
169  myX = myX / val;
170  myY = myY / val;
171  }
172 
174  friend std::ostream& operator<<(std::ostream& os, const Position& p) {
175  os << p.x() << "," << p.y();
176  if (p.z() != double(0.0)) {
177  os << "," << p.z();
178  }
179  return os;
180  }
181 
183  Position operator+(const Position& p2) const {
184  return Position(myX + p2.myX, myY + p2.myY, myZ + p2.myZ);
185  }
186 
188  Position operator-(const Position& p2) const {
189  return Position(myX - p2.myX, myY - p2.myY, myZ - p2.myZ);
190  }
191 
193  Position operator*(double scalar) const {
194  return Position(myX * scalar, myY * scalar, myZ * scalar);
195  }
196 
198  Position operator+(double offset) const {
199  const double length = distanceTo(Position(0, 0, 0));
200  if (length == 0) {
201  return *this;
202  }
203  const double scalar = (length + offset) / length;
204  return Position(myX * scalar, myY * scalar, myZ * scalar);
205  }
206 
208  bool operator==(const Position& p2) const {
209  return myX == p2.myX && myY == p2.myY && myZ == p2.myZ;
210  }
211 
213  bool operator!=(const Position& p2) const {
214  return myX != p2.myX || myY != p2.myY || myZ != p2.myZ;
215  }
216 
218  bool operator<(const Position& p2) const {
219  if (myX < p2.myX) {
220  return true;
221  } else if (myY < p2.myY) {
222  return true;
223  } else {
224  return myZ < p2.myZ;
225  }
226  }
227 
229  bool almostSame(const Position& p2, double maxDiv = POSITION_EPS) const {
230  return distanceTo(p2) < maxDiv;
231  }
232 
234  inline double distanceTo(const Position& p2) const {
235  return sqrt(distanceSquaredTo(p2));
236  }
237 
239  inline double distanceSquaredTo(const Position& p2) const {
240  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY) + (myZ - p2.myZ) * (myZ - p2.myZ);
241  }
242 
244  inline double distanceTo2D(const Position& p2) const {
245  return sqrt(distanceSquaredTo2D(p2));
246  }
247 
249  inline double distanceSquaredTo2D(const Position& p2) const {
250  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY);
251  }
252 
254  inline double angleTo2D(const Position& other) const {
255  return atan2(other.myY - myY, other.myX - myX);
256  }
257 
260  return Position(
261  myY * pos.myZ - myZ * pos.myY,
262  myZ * pos.myX - myX * pos.myZ,
263  myX * pos.myY - myY * pos.myX);
264  }
265 
267  inline double dotProduct(const Position& pos) {
268  return myX * pos.myX + myY * pos.myY + myZ * pos.myZ;
269  }
270 
272  Position rotateAround2D(double rad, const Position& origin);
273 
275  void swapXY() {
276  std::swap(myX, myY);
277  }
278 
280  bool isNAN() const {
281  return (std::isnan(myX) || std::isnan(myY) || std::isnan(myZ));
282  }
283 
285  static const Position INVALID;
286 
288  static const Position& invalidPosition() {
289  return INVALID;
290  }
291 
292 private:
294  double myX;
295 
297  double myY;
298 
300  double myZ;
301 };
302 
303 
304 #endif
305 
306 /****************************************************************************/
307 
Position::dotProduct
double dotProduct(const Position &pos)
returns the dot product (scalar product) between this point and the second one
Definition: Position.h:267
Position::rotateAround2D
Position rotateAround2D(double rad, const Position &origin)
rotate this position by rad around origin and return the result
Definition: Position.cpp:42
Position::mul
void mul(double mx, double my, double mz)
Multiplies position with the given values.
Definition: Position.h:120
Position::z
double z() const
Returns the z-position.
Definition: Position.h:67
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:285
Position::operator<
bool operator<(const Position &p2) const
lexicographical sorting for use in maps and sets
Definition: Position.h:218
Position::setx
void setx(double x)
set position x
Definition: Position.h:72
Position::operator-
Position operator-(const Position &p2) const
sub operator
Definition: Position.h:188
Position::myZ
double myZ
The z-position.
Definition: Position.h:300
Position::myY
double myY
The y-position.
Definition: Position.h:297
Position::sub
void sub(const Position &pos)
Substracts the given position from this one.
Definition: Position.h:160
Position::set
void set(const Position &pos)
set position with another position
Definition: Position.h:100
Position::operator+
Position operator+(const Position &p2) const
add operator
Definition: Position.h:183
Position::sub
void sub(double dx, double dy, double dz)
Substracts the given position from this one.
Definition: Position.h:153
Position::norm2d
void norm2d()
Definition: Position.h:167
Position::almostSame
bool almostSame(const Position &p2, double maxDiv=POSITION_EPS) const
check if two position is almost the sme as other
Definition: Position.h:229
Position::~Position
~Position()
Destructor.
Definition: Position.h:54
Position::set
void set(double x, double y, double z)
set positions x, y and z
Definition: Position.h:93
Position::distanceTo
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:234
Position::set
void set(double x, double y)
set positions x and y
Definition: Position.h:87
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:39
Position::x
double x() const
Returns the x-position.
Definition: Position.h:57
Position::operator+
Position operator+(double offset) const
keep the direction but modify the length of the (location) vector to length + scalar
Definition: Position.h:198
Position::sub
void sub(double dx, double dy)
Substracts the given position from this one.
Definition: Position.h:147
Position::mul
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:107
Position::Position
Position(double x, double y, double z)
Parametrised constructor.
Definition: Position.h:50
Position::distanceSquaredTo2D
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions)
Definition: Position.h:249
Position::angleTo2D
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
Definition: Position.h:254
Position::distanceTo2D
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:244
Position::y
double y() const
Returns the y-position.
Definition: Position.h:62
Position::operator==
bool operator==(const Position &p2) const
comparation operator
Definition: Position.h:208
Position::Position
Position(double x, double y)
Parametrised constructor (only for x-y)
Definition: Position.h:46
config.h
Position::mul
void mul(double mx, double my)
Multiplies position with the given values.
Definition: Position.h:114
Position::swapXY
void swapXY()
swap position X and Y
Definition: Position.h:275
Position::add
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:127
Position::crossProduct
Position crossProduct(const Position &pos)
returns the cross product between this point and the second one
Definition: Position.h:259
Position::invalidPosition
static const Position & invalidPosition()
reference to invalid position (needed if INVALID is taken by macro-definition)
Definition: Position.h:288
Position::operator<<
friend std::ostream & operator<<(std::ostream &os, const Position &p)
output operator
Definition: Position.h:174
Position::sety
void sety(double y)
set position y
Definition: Position.h:77
Position::add
void add(double dx, double dy, double dz)
Adds the given position to this one.
Definition: Position.h:140
Position::isNAN
bool isNAN() const
check if position is NAN
Definition: Position.h:280
Position::add
void add(double dx, double dy)
Adds the given position to this one.
Definition: Position.h:134
Position::setz
void setz(double z)
set position z
Definition: Position.h:82
POSITION_EPS
#define POSITION_EPS
Definition: config.h:169
Position::operator!=
bool operator!=(const Position &p2) const
difference operator
Definition: Position.h:213
Position::myX
double myX
The x-position.
Definition: Position.h:294
Position::operator*
Position operator*(double scalar) const
keep the direction but modify the length of the (location) vector to length * scalar
Definition: Position.h:193
Position::distanceSquaredTo
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:239
Position::Position
Position()
default constructor
Definition: Position.h:42