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