]> Shamusworld >> Repos - architektonas/blob - src/base/vector.cpp
Removed more QC_ madness...
[architektonas] / src / base / vector.cpp
1 // vector.cpp
2 //
3 // Part of the Architektonas Project
4 // Originally part of QCad Community Edition by Andrew Mustun
5 // Extensively rewritten and refactored by James L. Hammons
6 // (C) 2010 Underground Software
7 //
8 // JLH = James L. Hammons <jlhamm@acm.org>
9 //
10 // Who  When        What
11 // ---  ----------  -----------------------------------------------------------
12 // JLH  05/21/2010  Added this text. :-)
13 //
14
15 #include "vector.h"
16
17 #include "rs.h"                                                                 // For RS_MIN/MAXDOUBLE (!)
18 #include "rs_debug.h"
19 #include "rs_math.h"
20
21 /**
22  * Constructor for a point with default coordinates.
23  */
24 Vector::Vector()
25 {
26     //RS_DEBUG->print("Vector::Vector");
27     set(0.0, 0.0, 0.0);
28 }
29
30 /**
31  * Constructor for a point with given coordinates.
32  */
33 Vector::Vector(double vx, double vy, double vz)
34 {
35     //RS_DEBUG->print("Vector::Vector");
36     set(vx, vy, vz);
37 }
38
39 /**
40  * Constructor for a point with given coordinates in an array
41  * or three doubles.
42  */
43 //Vector::Vector(double v[]) {
44 //    set(v[0], v[1], v[2]);
45 //}
46
47 /**
48  * Constructor for a point with given valid flag.
49  *
50  * @param valid true: a valid vector with default coordinates is created.
51  *              false: an invalid vector is created
52  */
53 Vector::Vector(bool valid)
54 {
55         //RS_DEBUG->print("Vector::Vector");
56         set(0.0, 0.0, 0.0);
57         this->valid = valid;
58 }
59
60 /**
61  * Destructor.
62  */
63 Vector::~Vector()
64 {
65         //RS_DEBUG->print("Vector::~Vector");
66 }
67
68 /**
69  * Sets a new position for the vector.
70  */
71 void Vector::set(double vx, double vy, double vz)
72 {
73         x = vx;
74         y = vy;
75         z = vz;
76         valid = true;
77 }
78
79 /**
80  * Sets a new position for the vector in polar coordinates.
81  */
82 void Vector::setPolar(double radius, double angle)
83 {
84         x = radius * cos(angle);
85         y = radius * sin(angle);
86         z = 0.0;
87         valid = true;
88 }
89
90 /**
91  * @return The angle from zero to this vector (in rad).
92  */
93 double Vector::angle() const
94 {
95         double ret = 0.0;
96         double m = magnitude();
97
98         if (m > 1.0e-6)
99         {
100                 double dp = dotP(*this, Vector(1.0, 0.0));
101                 RS_DEBUG->print("Vector::angle: dp/m: %f/%f", dp, m);
102
103                 if (dp / m >= 1.0)
104                         ret = 0.0;
105                 else if (dp / m < -1.0)
106                         ret = M_PI;
107                 else
108                 ret = acos(dp / m);
109
110                 if (y < 0.0)
111             ret = 2 * M_PI - ret;
112     }
113
114         return ret;
115 }
116
117 /**
118  * @return The angle from this and the given coordinate (in rad).
119  */
120 double Vector::angleTo(const Vector & v) const
121 {
122         if (!valid || !v.valid)
123                 return 0.0;
124
125         return (v - (*this)).angle();
126 }
127
128 /**
129  * @return Magnitude (length) of the vector.
130  */
131 double Vector::magnitude() const
132 {
133         double ret = 0.0;
134     // Note that the z coordinate is also needed for 2d
135     //   (due to definition of crossP())
136         if (!valid)
137         {
138                 ret = 0.0;
139         }
140         else
141         {
142                 ret = sqrt(RS_Math::pow(x, 2) + RS_Math::pow(y, 2) + RS_Math::pow(z, 2));
143         }
144
145         return ret;
146 }
147
148 /**
149  *
150  */
151 Vector Vector::lerp(const Vector& v, double t) const
152 {
153     return Vector(x + (v.x - x) * t, y + (v.y - y) * t);
154 }
155
156 /**
157  * @return The distance between this and the given coordinate.
158  */
159 double Vector::distanceTo(const Vector & v) const
160 {
161         if (!valid || !v.valid)
162         {
163                 return RS_MAXDOUBLE;
164         }
165         else
166         {
167         return (*this - v).magnitude();
168         }
169 }
170
171 /**
172  * @return true is this vector is within the given range.
173  */
174 bool Vector::isInWindow(const Vector & firstCorner, const Vector & secondCorner)
175 {
176         double minX = std::min(firstCorner.x, secondCorner.x);
177         double maxX = std::max(firstCorner.x, secondCorner.x);
178         double minY = std::min(firstCorner.y, secondCorner.y);
179         double maxY = std::max(firstCorner.y, secondCorner.y);
180
181         return (x >= minX && x <= maxX && y >= minY && y <= maxY);
182 }
183
184 /**
185  * Moves this vector by the given offset. Equal to the operator +=.
186  */
187 Vector Vector::move(Vector offset)
188 {
189         *this += offset;
190         return *this;
191 }
192
193 /**
194  * Rotates this vector around 0/0 by the given angle.
195  */
196 Vector Vector::rotate(double ang)
197 {
198         RS_DEBUG->print("Vector::rotate: angle: %f", ang);
199
200         double r = magnitude();
201
202         RS_DEBUG->print("Vector::rotate: r: %f", r);
203
204         double a = angle() + ang;
205
206         RS_DEBUG->print("Vector::rotate: a: %f", a);
207
208         x = cos(a) * r;
209         y = sin(a) * r;
210
211         RS_DEBUG->print("Vector::rotate: x/y: %f/%f", x, y);
212
213         return *this;
214 }
215
216 /**
217  * Rotates this vector around the given center by the given angle.
218  */
219 Vector Vector::rotate(Vector center, double ang)
220 {
221         *this = center + (*this - center).rotate(ang);
222         return *this;
223 }
224
225 /**
226  * Scales this vector by the given factors with 0/0 as center.
227  */
228 Vector Vector::scale(Vector factor)
229 {
230         x *= factor.x;
231         y *= factor.y;
232         return *this;
233 }
234
235 /**
236  * Scales this vector by the given factors with the given center.
237  */
238 Vector Vector::scale(Vector center, Vector factor)
239 {
240         *this = center + (*this - center).scale(factor);
241         return *this;
242 }
243
244 /**
245  * Mirrors this vector at the given axis.
246  */
247 Vector Vector::mirror(Vector axisPoint1, Vector axisPoint2)
248 {
249         /*
250         RS_ConstructionLine axis(NULL,
251                 RS_ConstructionLineData(axisPoint1, axisPoint2));
252
253         Vector xp = axis.getNearestPointOnEntity(*this);
254         xp = xp - (*this);
255         (*this) += (xp*2);
256         */
257
258         double phi1 = axisPoint1.angleTo(*this);
259         double phi2 = axisPoint1.angleTo(axisPoint2) - phi1;
260         double r1 = axisPoint1.distanceTo(*this);
261         double r2 = axisPoint2.distanceTo(*this);
262
263         if (r1 < 1.0e-6 || r2 < 1.0e-6)
264         {
265                 // point touches one axis point
266         }
267         else
268         {
269                 setPolar(r1, phi1 + 2 * phi2);
270                 (*this) += axisPoint1;
271         }
272
273         return *this;
274 }
275
276 /**
277  * Streams the vector components to stdout. e.g.: "1/4/0"
278  */
279 std::ostream & operator<<(std::ostream & os, const Vector & v)
280 {
281     if (v.valid)
282         os << v.x << "/" << v.y << "/" << v.z;
283     else
284         os << "invalid vector";
285
286         return os;
287 }
288
289 /**
290  * binary + operator.
291  */
292 Vector Vector::operator+(const Vector & v) const
293 {
294         return Vector(x + v.x, y + v.y, z + v.z);
295 }
296
297 /**
298  * binary - operator.
299  */
300 Vector Vector::operator-(const Vector & v) const
301 {
302         return Vector(x - v.x, y - v.y, z - v.z);
303 }
304
305 /**
306  * binary * operator.
307  */
308 Vector Vector::operator*(double s) const
309 {
310         return Vector(x * s, y * s, z * s);
311 }
312
313 /**
314  * binary / operator.
315  */
316 Vector Vector::operator/(double s) const
317 {
318         return Vector(x / s, y / s, z / s);
319 }
320
321 /**
322  * unary - operator.
323  */
324 Vector Vector::operator-() const
325 {
326         return Vector(-x, -y, -z);
327 }
328
329 /**
330  * Scalarproduct (dot product).
331  */
332 double Vector::dotP(const Vector & v1, const Vector & v2)
333 {
334         return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
335 }
336
337 /**
338  * += operator. Assert: both vectors must be valid.
339  */
340 void Vector::operator+=(const Vector & v)
341 {
342         x += v.x;
343         y += v.y;
344         z += v.z;
345 }
346
347 /**
348  * -= operator
349  */
350 void Vector::operator-=(const Vector & v)
351 {
352         x -= v.x;
353         y -= v.y;
354         z -= v.z;
355 }
356
357 /**
358  * *= operator
359  */
360 void Vector::operator*=(double s)
361 {
362         x *= s;
363         y *= s;
364         z *= s;
365 }
366
367 /**
368  * == operator
369  */
370 bool Vector::operator==(const Vector & v) const
371 {
372         return (x == v.x && y == v.y && z == v.z && valid == v.valid);
373 }
374
375 bool Vector::operator!=(const Vector & v) const
376 {
377         return !operator==(v);
378 }
379
380 /**
381  * @return A vector with the minimum components from the vectors v1 and v2.
382  * These might be mixed components from both vectors.
383  */
384 Vector Vector::minimum (const Vector& v1, const Vector& v2)
385 {
386         return Vector (std::min(v1.x, v2.x), std::min(v1.y, v2.y), std::min(v1.z, v2.z));
387 }
388
389 /**
390  * @return A vector with the maximum values from the vectors v1 and v2
391  */
392 Vector Vector::maximum (const Vector& v1, const Vector& v2)
393 {
394         return Vector (std::max(v1.x, v2.x), std::max(v1.y, v2.y), std::max(v1.z, v2.z));
395 }
396
397 /**
398  * @return Cross product of two vectors.
399  */
400 Vector Vector::crossP(const Vector & v1, const Vector & v2)
401 {
402         return Vector(v1.y * v2.z - v1.z * v2.y, v1.z * v2.x - v1.x * v2.z, v1.x * v2.y - v1.y * v2.x);
403 }
404