]> Shamusworld >> Repos - architektonas/blob - src/base/rs_circle.cpp
Removed more QC_ madness...
[architektonas] / src / base / rs_circle.cpp
1 // rs_circle.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/28/2010  Added this text. :-)
13 //
14
15 #include "rs_circle.h"
16
17 #include "rs_constructionline.h"
18 #include "rs_information.h"
19 #include "rs_graphicview.h"
20 #include "paintintf.h"
21
22 /**
23  * Default constructor.
24  */
25 RS_Circle::RS_Circle(RS_EntityContainer * parent, const RS_CircleData & d):
26         RS_AtomicEntity(parent), data(d)
27 {
28     calculateBorders();
29 }
30
31 void RS_Circle::calculateBorders()
32 {
33         Vector r(data.radius,data.radius,0.0);
34         minV = data.center - r;
35         maxV = data.center + r;
36 }
37
38 /**
39  * @return Angle length in rad.
40  */
41 double RS_Circle::getAngleLength() const {
42     return 2*M_PI;
43 }
44
45
46
47 /**
48  * @return Length of the circle which is the circumference.
49  */
50 double RS_Circle::getLength() {
51         return 2*M_PI*data.radius;
52 }
53
54
55 /**
56  * Creates this circle from a center point and a radius.
57  *
58  * @param c Center.
59  * @param r Radius
60  */
61 bool RS_Circle::createFromCR(const Vector& c, double r) {
62     if (fabs(r)>RS_TOLERANCE) {
63         data.radius = fabs(r);
64         data.center = c;
65         return true;
66     } else {
67         RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Circle::createFromCR(): "
68                         "Cannot create a circle with radius 0.0.");
69         return false;
70     }
71 }
72
73
74
75 /**
76  * Creates this circle from two opposite points.
77  *
78  * @param p1 1st point.
79  * @param p2 2nd point.
80  */
81 bool RS_Circle::createFrom2P(const Vector& p1, const Vector& p2) {
82     if (p1.distanceTo(p2)>RS_TOLERANCE) {
83         data.radius = p1.distanceTo(p2)/2.0;
84         data.center = p1 + (p2-p1)/2.0;
85         return true;
86     } else {
87         RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Circle::createFrom2P(): "
88                         "Cannot create a circle with radius 0.0.");
89         return false;
90     }
91 }
92
93
94
95 /**
96  * Creates this circle from 3 given points which define the circle line.
97  *
98  * @param p1 1st point.
99  * @param p2 2nd point.
100  * @param p3 3rd point.
101  */
102 bool RS_Circle::createFrom3P(const Vector& p1, const Vector& p2,
103                              const Vector& p3) {
104     if (p1.distanceTo(p2)>RS_TOLERANCE &&
105             p2.distanceTo(p3)>RS_TOLERANCE &&
106             p3.distanceTo(p1)>RS_TOLERANCE) {
107
108         // middle points between 3 points:
109         Vector mp1, mp2;
110         Vector dir1, dir2;
111         double a1, a2;
112
113         // intersection of two middle lines
114         mp1 = (p1 + p2)/2.0;
115         a1 = p1.angleTo(p2) + M_PI/2.0;
116         dir1.setPolar(100.0, a1);
117         mp2 = (p2 + p3)/2.0;
118         a2 = p2.angleTo(p3) + M_PI/2.0;
119         dir2.setPolar(100.0, a2);
120
121         RS_ConstructionLineData d1(mp1, mp1 + dir1);
122         RS_ConstructionLineData d2(mp2, mp2 + dir2);
123         RS_ConstructionLine midLine1(NULL, d1);
124         RS_ConstructionLine midLine2(NULL, d2);
125
126         VectorSolutions sol =
127             RS_Information::getIntersection(&midLine1, &midLine2);
128
129         data.center = sol.get(0);
130         data.radius = data.center.distanceTo(p3);
131
132         if (sol.get(0).valid && data.radius<1.0e14 && data.radius>RS_TOLERANCE) {
133             return true;
134         } else {
135             RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Circle::createFrom3P(): "
136                             "Cannot create a circle with inf radius.");
137             return false;
138         }
139     } else {
140         RS_DEBUG->print(RS_Debug::D_WARNING, "RS_Circle::createFrom3P(): "
141                         "Cannot create a circle with radius 0.0.");
142         return false;
143     }
144 }
145
146
147
148 VectorSolutions RS_Circle::getRefPoints() {
149         Vector v1(data.radius, 0.0);
150         Vector v2(0.0, data.radius);
151
152         VectorSolutions ret(data.center,
153                 data.center+v1, data.center+v2,
154                 data.center-v1, data.center-v2);
155         return ret;
156 }
157
158
159 /**
160  * @return Always an invalid vector.
161  */
162 Vector RS_Circle::getNearestEndpoint(const Vector& /*coord*/, double* dist) {
163     if (dist!=NULL) {
164         *dist = RS_MAXDOUBLE;
165     }
166     return Vector(false);
167 }
168
169
170
171 Vector RS_Circle::getNearestPointOnEntity(const Vector& coord,
172         bool /*onEntity*/, double* dist, RS_Entity** entity) {
173
174     Vector vec(false);
175     if (entity!=NULL) {
176         *entity = this;
177     }
178
179     double angle = (coord-data.center).angle();
180     vec.setPolar(data.radius, angle);
181     vec+=data.center;
182
183     if (dist!=NULL) {
184         *dist = fabs((vec-data.center).magnitude()-data.radius);
185     }
186
187     return vec;
188 }
189
190
191
192 Vector RS_Circle::getNearestCenter(const Vector& coord,
193                                       double* dist) {
194     if (dist!=NULL) {
195         *dist = coord.distanceTo(data.center);
196     }
197     return data.center;
198 }
199
200
201
202 Vector RS_Circle::getNearestMiddle(const Vector& /*coord*/,
203                                       double* dist) {
204     if (dist!=NULL) {
205         *dist = RS_MAXDOUBLE;
206     }
207     return Vector(false);
208 }
209
210
211
212 Vector RS_Circle::getNearestDist(double /*distance*/,
213                                     const Vector& /*coord*/,
214                                     double* dist) {
215
216     if (dist!=NULL) {
217         *dist = RS_MAXDOUBLE;
218     }
219     return Vector(false);
220 }
221
222 Vector RS_Circle::getNearestDist(double /*distance*/,
223                                   bool /*startp*/) {
224
225     return Vector(false);
226 }
227
228
229
230 double RS_Circle::getDistanceToPoint(const Vector& coord,
231                                      RS_Entity** entity,
232                                      RS2::ResolveLevel, double) {
233     if (entity!=NULL) {
234         *entity = this;
235     }
236
237     return fabs((coord-data.center).magnitude() - data.radius);
238 }
239
240
241
242 void RS_Circle::move(Vector offset) {
243     data.center.move(offset);
244     calculateBorders();
245 }
246
247
248
249 void RS_Circle::rotate(Vector center, double angle) {
250     data.center.rotate(center, angle);
251     calculateBorders();
252 }
253
254
255
256 void RS_Circle::scale(Vector center, Vector factor) {
257     data.center.scale(center, factor);
258     data.radius *= factor.x;
259     calculateBorders();
260 }
261
262
263
264 void RS_Circle::mirror(Vector axisPoint1, Vector axisPoint2) {
265         data.center.mirror(axisPoint1, axisPoint2);
266     calculateBorders();
267 }
268
269 void RS_Circle::draw(PaintInterface * painter, RS_GraphicView * view, double /*patternOffset*/)
270 {
271     if (painter == NULL || view == NULL)
272         return;
273
274     // simple style-less lines
275     if (getPen().getLineType()==RS2::SolidLine ||
276             isSelected() ||
277             view->getDrawingMode()==RS2::ModePreview) {
278
279         painter->drawArc(view->toGui(getCenter()),
280                          getRadius() * view->getFactor().x,
281                          0.0, 2*M_PI,
282                          false);
283     } else {
284                 double styleFactor = getStyleFactor(view);
285                 if (styleFactor<0.0) {
286                 painter->drawArc(view->toGui(getCenter()),
287                          getRadius() * view->getFactor().x,
288                          0.0, 2*M_PI,
289                          false);
290                         return;
291                 }
292
293         // Pattern:
294         RS_LineTypePattern* pat;
295         if (isSelected()) {
296             pat = &patternSelected;
297         } else {
298             pat = view->getPattern(getPen().getLineType());
299         }
300
301         if (pat==NULL) {
302             return;
303         }
304
305                 if (getRadius()<1.0e-6) {
306                         return;
307                 }
308
309         // Pen to draw pattern is always solid:
310         RS_Pen pen = painter->getPen();
311         pen.setLineType(RS2::SolidLine);
312         painter->setPen(pen);
313
314         double* da;     // array of distances in x.
315         int i;          // index counter
316
317         double length = getAngleLength();
318
319         // create pattern:
320         da = new double[pat->num];
321
322         for (i=0; i<pat->num; ++i) {
323             da[i] = fabs(pat->pattern[i] * styleFactor)/getRadius();
324         }
325
326         double tot=0.0;
327         i=0;
328         bool done = false;
329         double curA = 0.0;
330         //double cx = getCenter().x * factor.x + offsetX;
331         //double cy = - a->getCenter().y * factor.y + getHeight() - offsetY;
332         Vector cp = view->toGui(getCenter());
333         double r = getRadius() * view->getFactor().x;
334
335         do {
336             if (pat->pattern[i] * styleFactor > 0.0) {
337                 if (tot+fabs(da[i])<length) {
338                     painter->drawArc(cp, r,
339                                      curA,
340                                      curA + da[i],
341                                      false);
342                 } else {
343                     painter->drawArc(cp, r,
344                                      curA,
345                                      2*M_PI,
346                                      false);
347                 }
348             }
349             curA+=da[i];
350             tot+=fabs(da[i]);
351             done=tot>length;
352
353             i++;
354             if (i>=pat->num) {
355                 i=0;
356             }
357         } while(!done);
358
359         delete[] da;
360     }
361 }
362
363
364
365 void RS_Circle::moveRef(const Vector& ref, const Vector& offset) {
366         Vector v1(data.radius, 0.0);
367         Vector v2(0.0, data.radius);
368
369     if (ref.distanceTo(data.center + v1)<1.0e-4) {
370                 data.radius = data.center.distanceTo(data.center + v1 + offset);
371     } else if (ref.distanceTo(data.center + v2)<1.0e-4) {
372                 data.radius = data.center.distanceTo(data.center + v2 + offset);
373     } else if (ref.distanceTo(data.center - v1)<1.0e-4) {
374                 data.radius = data.center.distanceTo(data.center - v1 + offset);
375     } else if (ref.distanceTo(data.center - v2)<1.0e-4) {
376                 data.radius = data.center.distanceTo(data.center - v2 + offset);
377         }
378 }
379
380
381 /**
382  * Dumps the circle's data to stdout.
383  */
384 std::ostream& operator << (std::ostream& os, const RS_Circle& a) {
385     os << " Circle: " << a.data << "\n";
386     return os;
387 }
388