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-2017 German Aerospace Center (DLR) and others.
4 /****************************************************************************/
5 //
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 //
11 /****************************************************************************/
20 // A position in the 2D- or 3D-world
21 /****************************************************************************/
22 #ifndef Position_h
23 #define Position_h
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #include <iostream>
30 #include <cmath>
31 
32 #ifdef _MSC_VER
33 #include <windows_config.h>
34 #else
35 #include <config.h>
36 #endif
37 
38 // ===========================================================================
39 // class definitions
40 // ===========================================================================
45 class Position {
46 public:
48  Position() : myX(0.0), myY(0.0), myZ(0.0) { }
49 
51  Position(double x, double y)
52  : myX(x), myY(y), myZ(0) { }
53 
55  Position(double x, double y, double z)
56  : myX(x), myY(y), myZ(z) { }
57 
59  ~Position() { }
60 
62  double x() const {
63  return myX;
64  }
65 
67  double y() const {
68  return myY;
69  }
70 
72  double z() const {
73  return myZ;
74  }
75 
77  void setx(double x) {
78  myX = x;
79  }
80 
82  void sety(double y) {
83  myY = y;
84  }
85 
87  void setz(double z) {
88  myZ = z;
89  }
90 
92  void set(double x, double y) {
93  myX = x;
94  myY = y;
95  }
96 
98  void set(double x, double y, double z) {
99  myX = x;
100  myY = y;
101  myZ = z;
102  }
103 
105  void set(const Position& pos) {
106  myX = pos.myX;
107  myY = pos.myY;
108  myZ = pos.myZ;
109  }
110 
112  void mul(double val) {
113  myX *= val;
114  myY *= val;
115  myZ *= val;
116  }
117 
119  void mul(double mx, double my) {
120  myX *= mx;
121  myY *= my;
122  }
123 
125  void mul(double mx, double my, double mz) {
126  myX *= mx;
127  myY *= my;
128  myZ *= mz;
129  }
130 
132  void add(const Position& pos) {
133  myX += pos.myX;
134  myY += pos.myY;
135  myZ += pos.myZ;
136  }
137 
139  void add(double dx, double dy) {
140  myX += dx;
141  myY += dy;
142  }
143 
145  void add(double dx, double dy, double dz) {
146  myX += dx;
147  myY += dy;
148  myZ += dz;
149  }
150 
152  void sub(double dx, double dy) {
153  myX -= dx;
154  myY -= dy;
155  }
156 
158  void sub(double dx, double dy, double dz) {
159  myX -= dx;
160  myY -= dy;
161  myZ -= dz;
162  }
163 
165  void sub(const Position& pos) {
166  myX -= pos.myX;
167  myY -= pos.myY;
168  myZ -= pos.myZ;
169  }
170 
172  void norm2d() {
173  double val = sqrt(myX * myX + myY * myY);
174  myX = myX / val;
175  myY = myY / val;
176  }
177 
179  friend std::ostream& operator<<(std::ostream& os, const Position& p) {
180  os << p.x() << "," << p.y();
181  if (p.z() != double(0.0)) {
182  os << "," << p.z();
183  }
184  return os;
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-(const Position& p2) const {
194  return Position(myX - p2.myX, myY - p2.myY, myZ - p2.myZ);
195  }
196 
198  Position operator*(double scalar) const {
199  return Position(myX * scalar, myY * scalar, myZ * scalar);
200  }
201 
203  Position operator+(double offset) const {
204  const double length = distanceTo(Position(0, 0, 0));
205  if (length == 0) {
206  return *this;
207  }
208  const double scalar = (length + offset) / length;
209  return Position(myX * scalar, myY * scalar, myZ * scalar);
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  return myX != p2.myX || myY != p2.myY || myZ != p2.myZ;
220  }
221 
223  bool operator<(const Position& p2) const {
224  if (myX < p2.myX) {
225  return true;
226  } else if (myY < p2.myY) {
227  return true;
228  } else {
229  return myZ < p2.myZ;
230  }
231  }
232 
234  bool almostSame(const Position& p2, double maxDiv = POSITION_EPS) const {
235  return distanceTo(p2) < maxDiv;
236  }
237 
239  inline double distanceTo(const Position& p2) const {
240  return sqrt(distanceSquaredTo(p2));
241  }
242 
244  inline double distanceSquaredTo(const Position& p2) const {
245  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY) + (myZ - p2.myZ) * (myZ - p2.myZ);
246  }
247 
249  inline double distanceTo2D(const Position& p2) const {
250  return sqrt(distanceSquaredTo2D(p2));
251  }
252 
254  inline double distanceSquaredTo2D(const Position& p2) const {
255  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY);
256  }
257 
259  inline double angleTo2D(const Position& other) const {
260  return atan2(other.myY - myY, other.myX - myX);
261  }
262 
265  return Position(
266  myY * pos.myZ - myZ * pos.myY,
267  myZ * pos.myX - myX * pos.myZ,
268  myX * pos.myY - myY * pos.myX);
269  }
270 
272  inline double dotProduct(const Position& pos) {
273  return myX * pos.myX + myY * pos.myY + myZ * pos.myZ;
274  }
275 
277  static const Position INVALID;
278 
280  static const Position& invalidPosition() {
281  return INVALID;
282  }
283 
284 private:
286  double myX;
287 
289  double myY;
290 
292  double myZ;
293 };
294 
295 
296 #endif
297 
298 /****************************************************************************/
299 
Position operator+(const Position &p2) const
add operator
Definition: Position.h:188
bool almostSame(const Position &p2, double maxDiv=POSITION_EPS) const
checki if two position is almost the sme as other
Definition: Position.h:234
Position operator+(double offset) const
keep the direction but modify the length of the (location) vector to length + scalar ...
Definition: Position.h:203
double z() const
Returns the z-position.
Definition: Position.h:72
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:132
void norm2d()
Definition: Position.h:172
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:249
double y() const
Returns the y-position.
Definition: Position.h:67
double x() const
Returns the x-position.
Definition: Position.h:62
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:259
~Position()
Destructor.
Definition: Position.h:59
double myZ
The z-position.
Definition: Position.h:292
void mul(double mx, double my, double mz)
Multiplies position with the given values.
Definition: Position.h:125
static const Position & invalidPosition()
reference to invalid position (needed if INVALID is taken by macro-definition)
Definition: Position.h:280
Position crossProduct(const Position &pos)
returns the cross product between this point and the second one
Definition: Position.h:264
void sub(const Position &pos)
Substracts the given position from this one.
Definition: Position.h:165
Position(double x, double y, double z)
parametrised constructor
Definition: Position.h:55
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:45
void setx(double x)
set position x
Definition: Position.h:77
bool operator==(const Position &p2) const
comparation operator
Definition: Position.h:213
void sub(double dx, double dy, double dz)
Substracts the given position from this one.
Definition: Position.h:158
double myX
The x-position.
Definition: Position.h:286
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:244
bool operator!=(const Position &p2) const
difference operator
Definition: Position.h:218
void mul(double mx, double my)
Multiplies position with the given values.
Definition: Position.h:119
Position(double x, double y)
parametrised constructor
Definition: Position.h:51
#define POSITION_EPS
Definition: config.h:175
void add(double dx, double dy, double dz)
Adds the given position to this one.
Definition: Position.h:145
friend std::ostream & operator<<(std::ostream &os, const Position &p)
output operator
Definition: Position.h:179
double dotProduct(const Position &pos)
returns the dot product (scalar product) between this point and the second one
Definition: Position.h:272
void sety(double y)
set position y
Definition: Position.h:82
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions) ...
Definition: Position.h:254
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:239
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:112
void add(double dx, double dy)
Adds the given position to this one.
Definition: Position.h:139
double myY
The y-position.
Definition: Position.h:289
Position()
default constructor
Definition: Position.h:48
Position operator*(double scalar) const
keep the direction but modify the length of the (location) vector to length * scalar ...
Definition: Position.h:198
Position operator-(const Position &p2) const
sub operator
Definition: Position.h:193
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:277
bool operator<(const Position &p2) const
lexicographical sorting for use in maps and sets
Definition: Position.h:223
void setz(double z)
set position z
Definition: Position.h:87
void sub(double dx, double dy)
Substracts the given position from this one.
Definition: Position.h:152