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-2020 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 /****************************************************************************/
21 // A position in the 2D- or 3D-world
22 /****************************************************************************/
23 #pragma once
24 #include <iostream>
25 #include <cmath>
26 
27 #include <config.h>
28 
29 // ===========================================================================
30 // class definitions
31 // ===========================================================================
36 class Position {
37 public:
40  myX(0.0), myY(0.0), myZ(0.0) { }
41 
43  Position(double x, double y) :
44  myX(x), myY(y), myZ(0) { }
45 
47  Position(double x, double y, double z) :
48  myX(x), myY(y), myZ(z) { }
49 
51  ~Position() { }
52 
54  inline double x() const {
55  return myX;
56  }
57 
59  inline double y() const {
60  return myY;
61  }
62 
64  inline double z() const {
65  return myZ;
66  }
67 
69  void setx(double x) {
70  myX = x;
71  }
72 
74  void sety(double y) {
75  myY = y;
76  }
77 
79  void setz(double z) {
80  myZ = z;
81  }
82 
84  void set(double x, double y) {
85  myX = x;
86  myY = y;
87  }
88 
90  void set(double x, double y, double z) {
91  myX = x;
92  myY = y;
93  myZ = z;
94  }
95 
97  void set(const Position& pos) {
98  myX = pos.myX;
99  myY = pos.myY;
100  myZ = pos.myZ;
101  }
102 
104  void mul(double val) {
105  myX *= val;
106  myY *= val;
107  myZ *= val;
108  }
109 
111  void mul(double mx, double my) {
112  myX *= mx;
113  myY *= my;
114  }
115 
117  void mul(double mx, double my, double mz) {
118  myX *= mx;
119  myY *= my;
120  myZ *= mz;
121  }
122 
124  void add(const Position& pos) {
125  myX += pos.myX;
126  myY += pos.myY;
127  myZ += pos.myZ;
128  }
129 
131  void add(double dx, double dy) {
132  myX += dx;
133  myY += dy;
134  }
135 
137  void add(double dx, double dy, double dz) {
138  myX += dx;
139  myY += dy;
140  myZ += dz;
141  }
142 
144  void sub(double dx, double dy) {
145  myX -= dx;
146  myY -= dy;
147  }
148 
150  void sub(double dx, double dy, double dz) {
151  myX -= dx;
152  myY -= dy;
153  myZ -= dz;
154  }
155 
157  void sub(const Position& pos) {
158  myX -= pos.myX;
159  myY -= pos.myY;
160  myZ -= pos.myZ;
161  }
162 
164  void norm2d() {
165  double val = sqrt(myX * myX + myY * myY);
166  myX = myX / val;
167  myY = myY / val;
168  }
169 
171  friend std::ostream& operator<<(std::ostream& os, const Position& p) {
172  os << p.x() << "," << p.y();
173  if (p.z() != double(0.0)) {
174  os << "," << p.z();
175  }
176  return os;
177  }
178 
180  Position operator+(const Position& p2) const {
181  return Position(myX + p2.myX, myY + p2.myY, myZ + p2.myZ);
182  }
183 
185  Position operator-(const Position& p2) const {
186  return Position(myX - p2.myX, myY - p2.myY, myZ - p2.myZ);
187  }
188 
190  Position operator*(double scalar) const {
191  return Position(myX * scalar, myY * scalar, myZ * scalar);
192  }
193 
195  Position operator+(double offset) const {
196  const double length = distanceTo(Position(0, 0, 0));
197  if (length == 0) {
198  return *this;
199  }
200  const double scalar = (length + offset) / length;
201  return Position(myX * scalar, myY * scalar, myZ * scalar);
202  }
203 
205  bool operator==(const Position& p2) const {
206  return myX == p2.myX && myY == p2.myY && myZ == p2.myZ;
207  }
208 
210  bool operator!=(const Position& p2) const {
211  return myX != p2.myX || myY != p2.myY || myZ != p2.myZ;
212  }
213 
215  bool operator<(const Position& p2) const {
216  if (myX < p2.myX) {
217  return true;
218  } else if (myY < p2.myY) {
219  return true;
220  } else {
221  return myZ < p2.myZ;
222  }
223  }
224 
226  bool almostSame(const Position& p2, double maxDiv = POSITION_EPS) const {
227  return distanceTo(p2) < maxDiv;
228  }
229 
231  inline double distanceTo(const Position& p2) const {
232  return sqrt(distanceSquaredTo(p2));
233  }
234 
236  inline double distanceSquaredTo(const Position& p2) const {
237  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY) + (myZ - p2.myZ) * (myZ - p2.myZ);
238  }
239 
241  inline double distanceTo2D(const Position& p2) const {
242  return sqrt(distanceSquaredTo2D(p2));
243  }
244 
246  inline double distanceSquaredTo2D(const Position& p2) const {
247  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY);
248  }
249 
251  inline double angleTo2D(const Position& other) const {
252  return atan2(other.myY - myY, other.myX - myX);
253  }
254 
257  return Position(
258  myY * pos.myZ - myZ * pos.myY,
259  myZ * pos.myX - myX * pos.myZ,
260  myX * pos.myY - myY * pos.myX);
261  }
262 
264  inline double dotProduct(const Position& pos) {
265  return myX * pos.myX + myY * pos.myY + myZ * pos.myZ;
266  }
267 
269  Position rotateAround2D(double rad, const Position& origin);
270 
272  void swapXY() {
273  std::swap(myX, myY);
274  }
275 
277  bool isNAN() const {
278  return (std::isnan(myX) || std::isnan(myY) || std::isnan(myZ));
279  }
280 
282  static const Position INVALID;
283 
284 private:
286  double myX;
287 
289  double myY;
290 
292  double myZ;
293 };
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:36
Position(double x, double y)
Parametrised constructor (only for x-y)
Definition: Position.h:43
Position(double x, double y, double z)
Parametrised constructor.
Definition: Position.h:47
void sub(const Position &pos)
Substracts the given position from this one.
Definition: Position.h:157
bool isNAN() const
check if position is NAN
Definition: Position.h:277
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions)
Definition: Position.h:246
void add(double dx, double dy)
Adds the given position to this one.
Definition: Position.h:131
void add(double dx, double dy, double dz)
Adds the given position to this one.
Definition: Position.h:137
Position()
default constructor
Definition: Position.h:39
void setx(double x)
set position x
Definition: Position.h:69
bool operator!=(const Position &p2) const
difference operator
Definition: Position.h:210
void norm2d()
Definition: Position.h:164
Position operator-(const Position &p2) const
sub operator
Definition: Position.h:185
void set(const Position &pos)
set position with another position
Definition: Position.h:97
void set(double x, double y)
set positions x and y
Definition: Position.h:84
double dotProduct(const Position &pos)
returns the dot product (scalar product) between this point and the second one
Definition: Position.h:264
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:282
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:241
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:231
void sub(double dx, double dy)
Substracts the given position from this one.
Definition: Position.h:144
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:236
void sub(double dx, double dy, double dz)
Substracts the given position from this one.
Definition: Position.h:150
Position operator+(double offset) const
keep the direction but modify the length of the (location) vector to length + scalar
Definition: Position.h:195
void mul(double mx, double my)
Multiplies position with the given values.
Definition: Position.h:111
double x() const
Returns the x-position.
Definition: Position.h:54
double myZ
The z-position.
Definition: Position.h:292
Position operator*(double scalar) const
keep the direction but modify the length of the (location) vector to length * scalar
Definition: Position.h:190
Position crossProduct(const Position &pos)
returns the cross product between this point and the second one
Definition: Position.h:256
void swapXY()
swap position X and Y
Definition: Position.h:272
friend std::ostream & operator<<(std::ostream &os, const Position &p)
output operator
Definition: Position.h:171
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:124
bool operator==(const Position &p2) const
comparation operator
Definition: Position.h:205
void set(double x, double y, double z)
set positions x, y and z
Definition: Position.h:90
Position operator+(const Position &p2) const
add operator
Definition: Position.h:180
void setz(double z)
set position z
Definition: Position.h:79
double myY
The y-position.
Definition: Position.h:289
~Position()
Destructor.
Definition: Position.h:51
bool operator<(const Position &p2) const
lexicographical sorting for use in maps and sets
Definition: Position.h:215
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:104
Position rotateAround2D(double rad, const Position &origin)
rotate this position by rad around origin and return the result
Definition: Position.cpp:41
double z() const
Returns the z-position.
Definition: Position.h:64
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:251
void sety(double y)
set position y
Definition: Position.h:74
double myX
The x-position.
Definition: Position.h:286
bool almostSame(const Position &p2, double maxDiv=POSITION_EPS) const
check if two position is almost the sme as other
Definition: Position.h:226
void mul(double mx, double my, double mz)
Multiplies position with the given values.
Definition: Position.h:117
double y() const
Returns the y-position.
Definition: Position.h:59