]> Shamusworld >> Repos - architektonas/blob - src/base/vectorsolutions.cpp
Removed more QC_ madness...
[architektonas] / src / base / vectorsolutions.cpp
1 // vectorsolutions.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 "vectorsolutions.h"
16
17 #include "rs.h"                                                                 // For RS_MIN/MAXDOUBLE (!)
18 #include "rs_math.h"
19
20 /**
21  * Constructor for no solution.
22  */
23 VectorSolutions::VectorSolutions(): vector(NULL)
24 {
25         clean();
26 }
27
28 /**
29  * Copy constructor
30  */
31 VectorSolutions::VectorSolutions(const VectorSolutions & s): vector(NULL)
32 {
33         alloc(s.getNumber());
34         setTangent(s.isTangent());
35
36         for(int i=0; i<s.getNumber(); ++i)
37                 set(i, s.get(i));
38 }
39
40 /**
41  * Constructor for num solutions.
42  */
43 VectorSolutions::VectorSolutions(int num): vector(NULL)
44 {
45         alloc(num);
46 }
47
48 /**
49  * Constructor for one solution.
50  */
51 VectorSolutions::VectorSolutions(const Vector & v1)
52 {
53         num = 1;
54         vector = new Vector[num];
55         vector[0] = v1;
56         tangent = false;
57 }
58
59 /**
60  * Constructor for two solutions.
61  */
62 VectorSolutions::VectorSolutions(const Vector & v1, const Vector & v2)
63 {
64         num = 2;
65         vector = new Vector[num];
66         vector[0] = v1;
67         vector[1] = v2;
68         tangent = false;
69 }
70
71 /**
72  * Constructor for three solutions.
73  */
74 VectorSolutions::VectorSolutions(const Vector & v1, const Vector & v2, const Vector & v3)
75 {
76         num = 3;
77         vector = new Vector[num];
78         vector[0] = v1;
79         vector[1] = v2;
80         vector[2] = v3;
81         tangent = false;
82 }
83
84 /**
85  * Constructor for four solutions.
86  */
87 VectorSolutions::VectorSolutions(const Vector & v1, const Vector & v2, const Vector & v3,
88         const Vector & v4)
89 {
90         num = 4;
91         vector = new Vector[num];
92         vector[0] = v1;
93         vector[1] = v2;
94         vector[2] = v3;
95         vector[3] = v4;
96         tangent = false;
97 }
98
99 /**
100  * Constructor for four solutions.
101  */
102 VectorSolutions::VectorSolutions(const Vector & v1, const Vector & v2, const Vector & v3,
103         const Vector & v4, const Vector & v5)
104 {
105         num = 5;
106         vector = new Vector[num];
107         vector[0] = v1;
108         vector[1] = v2;
109         vector[2] = v3;
110         vector[3] = v4;
111         vector[4] = v5;
112         tangent = false;
113 }
114
115 /**
116  * Destructor.
117  */
118 VectorSolutions::~VectorSolutions()
119 {
120         clean();
121 }
122
123 /**
124  * Allocates 'num' vectors.
125  */
126 void VectorSolutions::alloc(int num)
127 {
128         clean();
129         this->num = num;
130         vector = new Vector[num];
131
132         for(int i=0; i<num; ++i)
133                 vector[i] = Vector(false);
134
135         tangent = false;
136 }
137
138 /**
139  * Deletes vector array and resets everything.
140  */
141 void VectorSolutions::clean()
142 {
143         if (vector != NULL)
144                 delete[] vector;
145
146         vector = NULL;
147         num = 0;
148         tangent = false;
149 }
150
151 /**
152  * @return vector solution number i or an invalid vector if there
153  * are less solutions.
154  */
155 Vector VectorSolutions::get(int i) const
156 {
157         if (i < num)
158                 return vector[i];
159         else
160                 return Vector(false);
161 }
162
163 /**
164  * @return Number of solutions available.
165  */
166 int VectorSolutions::getNumber() const
167 {
168         return num;
169 }
170
171 /**
172  * @retval true There's at least one valid solution.
173  * @retval false There's no valid solution.
174  */
175 bool VectorSolutions::hasValid() const
176 {
177         for(int i=0; i<num; i++)
178                 if (vector[i].valid)
179                         return true;
180
181         return false;
182 }
183
184 /**
185  * Sets the solution i to the given vector.
186  * If i is greater than the current number of solutions available,
187  * nothing happens.
188  */
189 void VectorSolutions::set(int i, const Vector & v)
190 {
191         if (i < num)
192                 vector[i] = v;
193 }
194
195 /**
196  * Sets the tangent flag.
197  */
198 void VectorSolutions::setTangent(bool t)
199 {
200         tangent = t;
201 }
202
203 /**
204  * @return true if at least one of the solutions is a double solution
205  * (tangent).
206  */
207 bool VectorSolutions::isTangent() const
208 {
209         return tangent;
210 }
211
212 /**
213  * Rotates all vectors around the given center by the given angle.
214  */
215 void VectorSolutions::rotate(Vector center, double ang)
216 {
217         for(int i=0; i<num; i++)
218                 if (vector[i].valid)
219                         vector[i].rotate(center, ang);
220 }
221
222 /**
223  * Scales all vectors by the given factors with the given center.
224  */
225 void VectorSolutions::scale(Vector center, Vector factor)
226 {
227         for(int i=0; i<num; i++)
228                 if (vector[i].valid)
229                         vector[i].scale(center, factor);
230 }
231
232 /**
233  * @return vector solution which is the closest to the given coordinate.
234  * dist will contain the distance if it doesn't point to NULL (default).
235  */
236 Vector VectorSolutions::getClosest(const Vector & coord, double * dist, int * index) const
237 {
238         double curDist;
239         double minDist = RS_MAXDOUBLE;
240         Vector closestPoint(false);
241
242         for(int i=0; i<num; i++)
243         {
244                 if (vector[i].valid)
245                 {
246                         curDist = coord.distanceTo(vector[i]);
247
248                         if (curDist < minDist)
249                         {
250                                 closestPoint = vector[i];
251                                 minDist = curDist;
252
253                                 if (dist != NULL)
254                                         *dist = curDist;
255
256                                 if (index != NULL)
257                                         *index = i;
258                         }
259                 }
260         }
261
262         return closestPoint;
263 }
264
265 VectorSolutions VectorSolutions::operator=(const VectorSolutions & s)
266 {
267         alloc(s.getNumber());
268         setTangent(s.isTangent());
269
270         for (int i=0; i<s.getNumber(); ++i)
271                 set(i, s.get(i));
272
273         return *this;
274 }
275
276 std::ostream& operator << (std::ostream& os, const VectorSolutions& s)
277 {
278         for(int i=0; i<s.num; ++i)
279                 os << "(" << s.get(i) << ")\n";
280
281         os << " tangent: " << (int)s.isTangent() << "\n";
282         return os;
283 }