1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
|
/****************************************************************************
**
** This file is part of the LibreCAD project, a 2D CAD program
**
** Copyright (C) 2010 R. van Twisk (librecad@rvt.dds.nl)
** Copyright (C) 2001-2003 RibbonSoft. All rights reserved.
**
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file gpl-2.0.txt included in the
** packaging of this file.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
**
** This copyright notice MUST APPEAR in all copies of the script!
**
**********************************************************************/
#ifndef RS_ARC_H
#define RS_ARC_H
#include "rs_atomicentity.h"
class LC_Quadratic;
/**
* Holds the data that defines an arc.
*/
class RS_ArcData {
public:
RS_ArcData() {}
RS_ArcData(const RS_Vector& center,
double radius,
double angle1, double angle2,
bool reversed) {
this->center = center;
this->radius = radius;
this->angle1 = angle1;
this->angle2 = angle2;
this->reversed = reversed;
}
void reset() {
center = RS_Vector(false);
radius = 0.0;
angle1 = 0.0;
angle2 = 0.0;
reversed = false;
}
bool isValid() {
return (center.valid && radius>RS_TOLERANCE &&
fabs(angle1-angle2)>RS_TOLERANCE_ANGLE);
}
friend std::ostream& operator << (std::ostream& os, const RS_ArcData& ad) {
os << "(" << ad.center <<
"/" << ad.radius <<
" " << ad.angle1 <<
"," << ad.angle2 <<
")";
return os;
}
public:
RS_Vector center;
double radius;
double angle1;
double angle2;
bool reversed;
};
/**
* Class for an arc entity. All angles are in Rad.
*
* @author Andrew Mustun
*/
class RS_Arc : public RS_AtomicEntity {
public:
RS_Arc(RS_EntityContainer* parent,
const RS_ArcData& d);
virtual ~RS_Arc() {}
virtual RS_Entity* clone() {
RS_Arc* a = new RS_Arc(*this);
a->initId();
return a;
}
/** @return RS2::EntityArc */
virtual RS2::EntityType rtti() const {
return RS2::EntityArc;
}
/** @return true */
virtual bool isEdge() const {
return true;
}
/** @return Copy of data that defines the arc. **/
RS_ArcData getData() const {
return data;
}
virtual RS_VectorSolutions getRefPoints();
/** Sets new arc parameters. **/
void setData(RS_ArcData d) {
data = d;
}
/** @return The center point (x) of this arc */
virtual RS_Vector getCenter() const {
return data.center;
}
/** Sets new center. */
void setCenter(const RS_Vector& c) {
data.center = c;
}
/** @return The radius of this arc */
virtual double getRadius() const {
return data.radius;
}
/** Sets new radius. */
void setRadius(double r) {
data.radius = r;
}
/** @return The start angle of this arc */
double getAngle1() const {
return data.angle1;
}
/** Sets new start angle. */
void setAngle1(double a1) {
data.angle1 = a1;
}
/** @return The end angle of this arc */
double getAngle2() const {
return data.angle2;
}
/** Sets new end angle. */
void setAngle2(double a2) {
data.angle2 = a2;
}
/** get angle relative arc center*/
double getArcAngle(const RS_Vector& vp) {
return (vp - data.center).angle();
}
/**
* @return Direction 1. The angle at which the arc starts at
* the startpoint.
*/
double getDirection1() const {
if (!data.reversed) {
return RS_Math::correctAngle(data.angle1+M_PI/2.0);
}
else {
return RS_Math::correctAngle(data.angle1-M_PI/2.0);
}
}
/**
* @return Direction 2. The angle at which the arc starts at
* the endpoint.
*/
double getDirection2() const {
if (!data.reversed) {
return RS_Math::correctAngle(data.angle2-M_PI/2.0);
}
else {
return RS_Math::correctAngle(data.angle2+M_PI/2.0);
}
}
/**
* @retval true if the arc is reversed (clockwise),
* @retval false otherwise
*/
bool isReversed() const {
return data.reversed;
}
/** sets the reversed status. */
void setReversed(bool r) {
data.reversed = r;
}
/** @return Start point of the entity. */
virtual RS_Vector getStartpoint() const {
return startpoint;
}
/** @return End point of the entity. */
virtual RS_Vector getEndpoint() const {
return endpoint;
}
virtual QVector<RS_Entity* > offsetTwoSides(const double& distance) const;
/**
* implementations must revert the direction of an atomic entity
*/
virtual void revertDirection();
virtual void correctAngles();//make sure angleLength() is not more than 2*M_PI
virtual void moveStartpoint(const RS_Vector& pos);
virtual void moveEndpoint(const RS_Vector& pos);
virtual bool offset(const RS_Vector& position, const double& distance);
virtual void trimStartpoint(const RS_Vector& pos);
virtual void trimEndpoint(const RS_Vector& pos);
virtual RS2::Ending getTrimPoint(const RS_Vector& coord,
const RS_Vector& trimPoint);
/** choose an intersection to trim to based on mouse point */
virtual RS_Vector prepareTrim(const RS_Vector& mousePoint,
const RS_VectorSolutions& trimSol);
virtual void reverse();
virtual RS_Vector getMiddlePoint() const;
double getAngleLength() const;
virtual double getLength() const;
double getBulge() const;
bool createFrom3P(const RS_Vector& p1, const RS_Vector& p2,
const RS_Vector& p3);
bool createFrom2PDirectionRadius(const RS_Vector& startPoint, const RS_Vector& endPoint,
double direction1, double radius);
bool createFrom2PDirectionAngle(const RS_Vector& startPoint, const RS_Vector& endPoint,
double direction1, double angleLength);
bool createFrom2PBulge(const RS_Vector& startPoint, const RS_Vector& endPoint,
double bulge);
virtual RS_Vector getNearestEndpoint(const RS_Vector& coord,
double* dist = NULL)const;
virtual RS_Vector getNearestPointOnEntity(const RS_Vector& coord,
bool onEntity = true, double* dist = NULL, RS_Entity** entity=NULL)const;
virtual RS_Vector getNearestCenter(const RS_Vector& coord,
double* dist = NULL);
virtual RS_Vector getNearestMiddle(const RS_Vector& coord,
double* dist = NULL,
int middlePoints = 1
)const;
virtual RS_Vector getNearestDist(double distance,
const RS_Vector& coord,
double* dist = NULL);
virtual RS_Vector getNearestDist(double distance,
bool startp);
virtual RS_Vector getNearestOrthTan(const RS_Vector& coord,
const RS_Line& normal,
bool onEntity = false);
virtual RS_VectorSolutions getTangentPoint(const RS_Vector& point) const;//find the tangential points seeing from given point
virtual RS_Vector getTangentDirection(const RS_Vector& point)const;
virtual double getDistanceToPoint(const RS_Vector& coord,
RS_Entity** entity=NULL,
RS2::ResolveLevel level=RS2::ResolveNone,
double solidDist = RS_MAXDOUBLE) const;
virtual void move(const RS_Vector& offset);
virtual void rotate(const RS_Vector& center, const double& angle);
virtual void rotate(const RS_Vector& center, const RS_Vector& angleVector);
virtual void scale(const RS_Vector& center, const RS_Vector& factor);
virtual void mirror(const RS_Vector& axisPoint1, const RS_Vector& axisPoint2);
virtual void moveRef(const RS_Vector& ref, const RS_Vector& offset);
virtual void stretch(const RS_Vector& firstCorner,
const RS_Vector& secondCorner,
const RS_Vector& offset);
/** find the visible part of the arc, and call drawVisible() to draw */
virtual void draw(RS_Painter* painter, RS_GraphicView* view, double& patternOffset);
/** directly draw the arc, assuming the whole arc is within visible window */
virtual void drawVisible(RS_Painter* painter, RS_GraphicView* view, double& patternOffset);
friend std::ostream& operator << (std::ostream& os, const RS_Arc& a);
virtual void calculateEndpoints();
virtual void calculateBorders();
/** return the equation of the entity
for quadratic,
return a vector contains:
m0 x^2 + m1 xy + m2 y^2 + m3 x + m4 y + m5 =0
for linear:
m0 x + m1 y + m2 =0
**/
virtual LC_Quadratic getQuadratic() const;
protected:
RS_ArcData data;
/**
* Startpoint. This is redundant but stored for performance
* reasons.
*/
RS_Vector startpoint;
/**
* Endpoint. This is redundant but stored for performance
* reasons.
*/
RS_Vector endpoint;
};
#endif
|