SUMO - Simulation of Urban MObility
Position.h
Go to the documentation of this file.
1 /****************************************************************************/
10 // A position in the 2D- or 3D-world
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
13 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 #ifndef Position_h
24 #define Position_h
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #include <iostream>
31 #include <cmath>
32 
33 #ifdef _MSC_VER
34 #include <windows_config.h>
35 #else
36 #include <config.h>
37 #endif
38 
39 // ===========================================================================
40 // class definitions
41 // ===========================================================================
46 class Position {
47 public:
49  Position() : myX(0.0), myY(0.0), myZ(0.0) { }
50 
52  Position(double x, double y)
53  : myX(x), myY(y), myZ(0) { }
54 
56  Position(double x, double y, double z)
57  : myX(x), myY(y), myZ(z) { }
58 
60  ~Position() { }
61 
63  double x() const {
64  return myX;
65  }
66 
68  double y() const {
69  return myY;
70  }
71 
73  double z() const {
74  return myZ;
75  }
76 
78  void setx(double x) {
79  myX = x;
80  }
81 
83  void sety(double y) {
84  myY = y;
85  }
86 
88  void setz(double z) {
89  myZ = z;
90  }
91 
93  void set(double x, double y) {
94  myX = x;
95  myY = y;
96  }
97 
99  void set(double x, double y, double z) {
100  myX = x;
101  myY = y;
102  myZ = z;
103  }
104 
106  void set(const Position& pos) {
107  myX = pos.myX;
108  myY = pos.myY;
109  myZ = pos.myZ;
110  }
111 
113  void mul(double val) {
114  myX *= val;
115  myY *= val;
116  myZ *= val;
117  }
118 
120  void mul(double mx, double my) {
121  myX *= mx;
122  myY *= my;
123  }
124 
126  void mul(double mx, double my, double mz) {
127  myX *= mx;
128  myY *= my;
129  myZ *= mz;
130  }
131 
133  void add(const Position& pos) {
134  myX += pos.myX;
135  myY += pos.myY;
136  myZ += pos.myZ;
137  }
138 
140  void add(double dx, double dy) {
141  myX += dx;
142  myY += dy;
143  }
144 
146  void add(double dx, double dy, double dz) {
147  myX += dx;
148  myY += dy;
149  myZ += dz;
150  }
151 
153  void sub(double dx, double dy) {
154  myX -= dx;
155  myY -= dy;
156  }
157 
159  void sub(double dx, double dy, double dz) {
160  myX -= dx;
161  myY -= dy;
162  myZ -= dz;
163  }
164 
166  void sub(const Position& pos) {
167  myX -= pos.myX;
168  myY -= pos.myY;
169  myZ -= pos.myZ;
170  }
171 
173  void norm2d() {
174  double val = sqrt(myX * myX + myY * myY);
175  myX = myX / val;
176  myY = myY / val;
177  }
178 
180  friend std::ostream& operator<<(std::ostream& os, const Position& p) {
181  os << p.x() << "," << p.y();
182  if (p.z() != double(0.0)) {
183  os << "," << p.z();
184  }
185  return os;
186  }
187 
189  Position operator+(const Position& p2) const {
190  return Position(myX + p2.myX, myY + p2.myY, myZ + p2.myZ);
191  }
192 
194  Position operator-(const Position& p2) const {
195  return Position(myX - p2.myX, myY - p2.myY, myZ - p2.myZ);
196  }
197 
199  Position operator*(double scalar) const {
200  return Position(myX * scalar, myY * scalar, myZ * scalar);
201  }
202 
204  Position operator+(double offset) const {
205  const double length = distanceTo(Position(0, 0, 0));
206  if (length == 0) {
207  return *this;
208  }
209  const double scalar = (length + offset) / length;
210  return Position(myX * scalar, myY * scalar, myZ * scalar);
211  }
212 
214  bool operator==(const Position& p2) const {
215  return myX == p2.myX && myY == p2.myY && myZ == p2.myZ;
216  }
217 
219  bool operator!=(const Position& p2) const {
220  return myX != p2.myX || myY != p2.myY || myZ != p2.myZ;
221  }
222 
224  bool operator<(const Position& p2) const {
225  if (myX < p2.myX) {
226  return true;
227  } else if (myY < p2.myY) {
228  return true;
229  } else {
230  return myZ < p2.myZ;
231  }
232  }
233 
235  bool almostSame(const Position& p2, double maxDiv = POSITION_EPS) const {
236  return distanceTo(p2) < maxDiv;
237  }
238 
240  inline double distanceTo(const Position& p2) const {
241  return sqrt(distanceSquaredTo(p2));
242  }
243 
245  inline double distanceSquaredTo(const Position& p2) const {
246  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY) + (myZ - p2.myZ) * (myZ - p2.myZ);
247  }
248 
250  inline double distanceTo2D(const Position& p2) const {
251  return sqrt(distanceSquaredTo2D(p2));
252  }
253 
255  inline double distanceSquaredTo2D(const Position& p2) const {
256  return (myX - p2.myX) * (myX - p2.myX) + (myY - p2.myY) * (myY - p2.myY);
257  }
258 
260  inline double angleTo2D(const Position& other) const {
261  return atan2(other.myY - myY, other.myX - myX);
262  }
263 
266  return Position(
267  myY * pos.myZ - myZ * pos.myY,
268  myZ * pos.myX - myX * pos.myZ,
269  myX * pos.myY - myY * pos.myX);
270  }
271 
273  inline double dotProduct(const Position& pos) {
274  return myX * pos.myX + myY * pos.myY + myZ * pos.myZ;
275  }
276 
278  static const Position INVALID;
279 
280 private:
282  double myX;
283 
285  double myY;
286 
288  double myZ;
289 };
290 
291 
292 #endif
293 
294 /****************************************************************************/
295 
Position operator+(const Position &p2) const
add operator
Definition: Position.h:189
bool almostSame(const Position &p2, double maxDiv=POSITION_EPS) const
checki if two position is almost the sme as other
Definition: Position.h:235
Position operator+(double offset) const
keep the direction but modify the length of the (location) vector to length + scalar ...
Definition: Position.h:204
double z() const
Returns the z-position.
Definition: Position.h:73
void add(const Position &pos)
Adds the given position to this one.
Definition: Position.h:133
void norm2d()
Definition: Position.h:173
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
Definition: Position.h:250
double y() const
Returns the y-position.
Definition: Position.h:68
double x() const
Returns the x-position.
Definition: Position.h:63
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:260
~Position()
Destructor.
Definition: Position.h:60
double myZ
The z-position.
Definition: Position.h:288
void mul(double mx, double my, double mz)
Multiplies position with the given values.
Definition: Position.h:126
Position crossProduct(const Position &pos)
returns the cross product between this point and the second one
Definition: Position.h:265
void sub(const Position &pos)
Substracts the given position from this one.
Definition: Position.h:166
Position(double x, double y, double z)
parametrised constructor
Definition: Position.h:56
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
void setx(double x)
set position x
Definition: Position.h:78
bool operator==(const Position &p2) const
comparation operator
Definition: Position.h:214
void sub(double dx, double dy, double dz)
Substracts the given position from this one.
Definition: Position.h:159
double myX
The x-position.
Definition: Position.h:282
double distanceSquaredTo(const Position &p2) const
returns the square of the distance to another position
Definition: Position.h:245
bool operator!=(const Position &p2) const
difference operator
Definition: Position.h:219
void mul(double mx, double my)
Multiplies position with the given values.
Definition: Position.h:120
Position(double x, double y)
parametrised constructor
Definition: Position.h:52
#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:146
friend std::ostream & operator<<(std::ostream &os, const Position &p)
output operator
Definition: Position.h:180
double dotProduct(const Position &pos)
returns the dot product (scalar product) between this point and the second one
Definition: Position.h:273
void sety(double y)
set position y
Definition: Position.h:83
double distanceSquaredTo2D(const Position &p2) const
returns the square of the distance to another position (Only using x and y positions) ...
Definition: Position.h:255
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:240
void mul(double val)
Multiplies both positions with the given value.
Definition: Position.h:113
void add(double dx, double dy)
Adds the given position to this one.
Definition: Position.h:140
double myY
The y-position.
Definition: Position.h:285
Position()
default constructor
Definition: Position.h:49
Position operator*(double scalar) const
keep the direction but modify the length of the (location) vector to length * scalar ...
Definition: Position.h:199
Position operator-(const Position &p2) const
sub operator
Definition: Position.h:194
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:278
bool operator<(const Position &p2) const
lexicographical sorting for use in maps and sets
Definition: Position.h:224
void setz(double z)
set position z
Definition: Position.h:88
void sub(double dx, double dy)
Substracts the given position from this one.
Definition: Position.h:153