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 /****************************************************************************/
17 // A position in the 2D- or 3D-world
18 /****************************************************************************/
19 #ifndef Position_h
20 #define Position_h
21 
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <iostream>
27 #include <cmath>
28 
29 #include <config.h>
30 
31 // ===========================================================================
32 // class definitions
33 // ===========================================================================
38 class Position {
39 public:
42  myX(0.0), myY(0.0), myZ(0.0) { }
43 
45  Position(double x, double y) :
46  myX(x), myY(y), myZ(0) { }
47 
49  Position(double x, double y, double z) :
50  myX(x), myY(y), myZ(z) { }
51 
53  ~Position() { }
54 
56  inline double x() const {
57  return myX;
58  }
59 
61  inline double y() const {
62  return myY;
63  }
64 
66  inline double z() const {
67  return myZ;
68  }
69 
71  void setx(double x) {
72  myX = x;
73  }
74 
76  void sety(double y) {
77  myY = y;
78  }
79 
81  void setz(double z) {
82  myZ = z;
83  }
84 
86  void set(double x, double y) {
87  myX = x;
88  myY = y;
89  }
90 
92  void set(double x, double y, double z) {
93  myX = x;
94  myY = y;
95  myZ = z;
96  }
97 
99  void set(const Position& pos) {
100  myX = pos.myX;
101  myY = pos.myY;
102  myZ = pos.myZ;
103  }
104 
106  void mul(double val) {
107  myX *= val;
108  myY *= val;
109  myZ *= val;
110  }
111 
113  void mul(double mx, double my) {
114  myX *= mx;
115  myY *= my;
116  }
117 
119  void mul(double mx, double my, double mz) {
120  myX *= mx;
121  myY *= my;
122  myZ *= mz;
123  }
124 
126  void add(const Position& pos) {
127  myX += pos.myX;
128  myY += pos.myY;
129  myZ += pos.myZ;
130  }
131 
133  void add(double dx, double dy) {
134  myX += dx;
135  myY += dy;
136  }
137 
139  void add(double dx, double dy, double dz) {
140  myX += dx;
141  myY += dy;
142  myZ += dz;
143  }
144 
146  void sub(double dx, double dy) {
147  myX -= dx;
148  myY -= dy;
149  }
150 
152  void sub(double dx, double dy, double dz) {
153  myX -= dx;
154  myY -= dy;
155  myZ -= dz;
156  }
157 
159  void sub(const Position& pos) {
160  myX -= pos.myX;
161  myY -= pos.myY;
162  myZ -= pos.myZ;
163  }
164 
166  void norm2d() {
167  double val = sqrt(myX * myX + myY * myY);
168  myX = myX / val;
169  myY = myY / val;
170  }
171 
173  friend std::ostream& operator<<(std::ostream& os, const Position& p) {
174  os << p.x() << "," << p.y();
175  if (p.z() != double(0.0)) {
176  os << "," << p.z();
177  }
178  return os;
179  }
180 
182  Position operator+(const Position& p2) const {
183  return Position(myX + p2.myX, myY + p2.myY, myZ + p2.myZ);
184  }
185 
187  Position operator-(const Position& p2) const {
188  return Position(myX - p2.myX, myY - p2.myY, myZ - p2.myZ);
189  }
190 
192  Position operator*(double scalar) const {
193  return Position(myX * scalar, myY * scalar, myZ * scalar);
194  }
195 
197  Position operator+(double offset) const {
198  const double length = distanceTo(Position(0, 0, 0));
199  if (length == 0) {
200  return *this;
201  }
202  const double scalar = (length + offset) / length;
203  return Position(myX * scalar, myY * scalar, myZ * scalar);
204  }
205 
207  bool operator==(const Position& p2) const {
208  return myX == p2.myX && myY == p2.myY && myZ == p2.myZ;
209  }
210 
212  bool operator!=(const Position& p2) const {
213  return myX != p2.myX || myY != p2.myY || myZ != p2.myZ;
214  }
215 
217  bool operator<(const Position& p2) const {
218  if (myX < p2.myX) {
219  return true;
220  } else if (myY < p2.myY) {
221  return true;
222  } else {
223  return myZ < p2.myZ;
224  }
225  }
226 
228  bool almostSame(const Position& p2, double maxDiv = POSITION_EPS) const {
229  return distanceTo(p2) < maxDiv;
230  }
231 
233  inline double distanceTo(const Position& p2) const {
234  return sqrt(distanceSquaredTo(p2));
235  }
236 
238  inline double distanceSquaredTo(const Position& p2) const {
239  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY) + (myZ - p2.myZ) * (myZ - p2.myZ);
240  }
241 
243  inline double distanceTo2D(const Position& p2) const {
244  return sqrt(distanceSquaredTo2D(p2));
245  }
246 
248  inline double distanceSquaredTo2D(const Position& p2) const {
249  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY);
250  }
251 
253  inline double angleTo2D(const Position& other) const {
254  return atan2(other.myY - myY, other.myX - myX);
255  }
256 
259  return Position(
260  myY * pos.myZ - myZ * pos.myY,
261  myZ * pos.myX - myX * pos.myZ,
262  myX * pos.myY - myY * pos.myX);
263  }
264 
266  inline double dotProduct(const Position& pos) {
267  return myX * pos.myX + myY * pos.myY + myZ * pos.myZ;
268  }
269 
271  Position rotateAround2D(double rad, const Position& origin);
272 
274  void swapXY() {
275  std::swap(myX, myY);
276  }
277 
279  bool isNAN() const {
280  return (std::isnan(myX) || std::isnan(myY) || std::isnan(myZ));
281  }
282 
284  static const Position INVALID;
285 
287  static const Position& invalidPosition() {
288  return INVALID;
289  }
290 
291 private:
293  double myX;
294 
296  double myY;
297 
299  double myZ;
300 };
301 
302 
303 #endif
304 
305 /****************************************************************************/
306 
Position::dotProduct
double dotProduct(const Position &pos)
returns the dot product (scalar product) between this point and the second one
Definition: Position.h:266
Position::rotateAround2D
Position rotateAround2D(double rad, const Position &origin)
rotate this position by rad around origin and return the result
Definition: Position.cpp:41
Position::mul
void mul(double mx, double my, double mz)
Multiplies position with the given values.
Definition: Position.h:119
Position::z
double z() const
Returns the z-position.
Definition: Position.h:66
Position::INVALID
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:284
Position::operator<
bool operator<(const Position &p2) const
lexicographical sorting for use in maps and sets
Definition: Position.h:217
Position::setx
void setx(double x)
set position x
Definition: Position.h:71
Position::operator-
Position operator-(const Position &p2) const
sub operator
Definition: Position.h:187
Position::myZ
double myZ
The z-position.
Definition: Position.h:299
Position::myY
double myY
The y-position.
Definition: Position.h:296
Position::sub
void sub(const Position &pos)
Substracts the given position from this one.
Definition: Position.h:159
Position::set
void set(const Position &pos)
set position with another position
Definition: Position.h:99
Position::operator+
Position operator+(const Position &p2) const
add operator
Definition: Position.h:182
Position::sub
void sub(double dx, double dy, double dz)
Substracts the given position from this one.
Definition: Position.h:152
Position::norm2d
void norm2d()
Definition: Position.h:166
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:228
Position::~Position
~Position()
Destructor.
Definition: Position.h:53
Position::set
void set(double x, double y, double z)
set positions x, y and z
Definition: Position.h:92
Position::distanceTo
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:233
Position::set
void set(double x, double y)
set positions x and y
Definition: Position.h:86
Position
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:38
Position::x
double x() const
Returns the x-position.
Definition: Position.h:56
Position::operator+
Position operator+(double offset) const
keep the direction but modify the length of the (location) vector to length + scalar
Definition: Position.h:197
Position::sub
void sub(double dx, double dy)
Substracts the given position from this one.
Definition: Position.h:146
Position::mul
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:106
Position::Position
Position(double x, double y, double z)
Parametrised constructor.
Definition: Position.h:49
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:248
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:253
Position::distanceTo2D
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:243
Position::y
double y() const
Returns the y-position.
Definition: Position.h:61
Position::operator==
bool operator==(const Position &p2) const
comparation operator
Definition: Position.h:207
Position::Position
Position(double x, double y)
Parametrised constructor (only for x-y)
Definition: Position.h:45
config.h
Position::mul
void mul(double mx, double my)
Multiplies position with the given values.
Definition: Position.h:113
Position::swapXY
void swapXY()
swap position X and Y
Definition: Position.h:274
Position::add
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:126
Position::crossProduct
Position crossProduct(const Position &pos)
returns the cross product between this point and the second one
Definition: Position.h:258
Position::invalidPosition
static const Position & invalidPosition()
reference to invalid position (needed if INVALID is taken by macro-definition)
Definition: Position.h:287
Position::operator<<
friend std::ostream & operator<<(std::ostream &os, const Position &p)
output operator
Definition: Position.h:173
Position::sety
void sety(double y)
set position y
Definition: Position.h:76
Position::add
void add(double dx, double dy, double dz)
Adds the given position to this one.
Definition: Position.h:139
Position::isNAN
bool isNAN() const
check if position is NAN
Definition: Position.h:279
Position::add
void add(double dx, double dy)
Adds the given position to this one.
Definition: Position.h:133
Position::setz
void setz(double z)
set position z
Definition: Position.h:81
POSITION_EPS
#define POSITION_EPS
Definition: config.h:172
Position::operator!=
bool operator!=(const Position &p2) const
difference operator
Definition: Position.h:212
Position::myX
double myX
The x-position.
Definition: Position.h:293
Position::operator*
Position operator*(double scalar) const
keep the direction but modify the length of the (location) vector to length * scalar
Definition: Position.h:192
Position::distanceSquaredTo
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:238
Position::Position
Position()
default constructor
Definition: Position.h:41