Line data Source code
1 : /*******************************************************************************
2 : * Project: libopencad
3 : * Purpose: OpenSource CAD formats support library
4 : * Author: Alexandr Borzykh, mush3d at gmail.com
5 : * Author: Dmitry Baryshnikov, bishop.dev@gmail.com
6 : * Language: C++
7 : *******************************************************************************
8 : * The MIT License (MIT)
9 : *
10 : * Copyright (c) 2016 Alexandr Borzykh
11 : * Copyright (c) 2016 NextGIS, <info@nextgis.com>
12 : *
13 : * SPDX-License-Identifier: MIT
14 : *******************************************************************************/
15 : #include "cadgeometry.h"
16 :
17 : #include <cmath>
18 : #include <iostream>
19 :
20 : using namespace std;
21 :
22 : //------------------------------------------------------------------------------
23 : // CADGeometry
24 : //------------------------------------------------------------------------------
25 :
26 0 : void Matrix::translate( const CADVector& vector )
27 : {
28 0 : double a00 = matrix[0];
29 0 : double a01 = matrix[1];
30 0 : double a02 = matrix[2];
31 0 : double a10 = matrix[3];
32 0 : double a11 = matrix[4];
33 0 : double a12 = matrix[5];
34 0 : double a20 = matrix[6];
35 0 : double a21 = matrix[7];
36 0 : double a22 = matrix[8];
37 :
38 0 : matrix[6] = vector.getX() * a00 + vector.getY() * a10 + a20;
39 0 : matrix[7] = vector.getX() * a01 + vector.getY() * a11 + a21;
40 0 : matrix[8] = vector.getX() * a02 + vector.getY() * a12 + a22;
41 0 : }
42 :
43 0 : void Matrix::rotate( double rotation )
44 : {
45 0 : const double s = sin( rotation );
46 0 : const double c = cos( rotation );
47 0 : double a00 = matrix[0];
48 0 : double a01 = matrix[1];
49 0 : double a02 = matrix[2];
50 0 : double a10 = matrix[3];
51 0 : double a11 = matrix[4];
52 0 : double a12 = matrix[5];
53 :
54 0 : matrix[0] = c * a00 + s * a10;
55 0 : matrix[1] = c * a01 + s * a11;
56 0 : matrix[2] = c * a02 + s * a12;
57 :
58 0 : matrix[3] = c * a10 - s * a00;
59 0 : matrix[4] = c * a11 - s * a01;
60 0 : matrix[5] = c * a12 - s * a02;
61 0 : }
62 :
63 0 : void Matrix::scale( const CADVector& vector )
64 : {
65 0 : matrix[0] *= vector.getX();
66 0 : matrix[1] *= vector.getX();
67 0 : matrix[2] *= vector.getX();
68 0 : matrix[3] *= vector.getY();
69 0 : matrix[4] *= vector.getY();
70 0 : matrix[5] *= vector.getY();
71 0 : }
72 :
73 0 : CADVector Matrix::multiply( const CADVector& vector ) const
74 : {
75 0 : CADVector out;
76 0 : out.setX( vector.getX() * matrix[0] + vector.getY() * matrix[1] + vector.getZ() * matrix[2] );
77 0 : out.setY( vector.getX() * matrix[3] + vector.getY() * matrix[4] + vector.getZ() * matrix[5] );
78 0 : out.setZ( vector.getX() * matrix[6] + vector.getY() * matrix[7] + vector.getZ() * matrix[8] );
79 0 : return out;
80 : }
81 :
82 : //------------------------------------------------------------------------------
83 : // CADGeometry
84 : //------------------------------------------------------------------------------
85 :
86 19 : CADGeometry::CADGeometry() :
87 : geometryType( UNDEFINED ),
88 19 : m_thickness( 0 )
89 : {
90 19 : geometry_color.R = 0;
91 19 : geometry_color.G = 0;
92 19 : geometry_color.B = 0;
93 19 : }
94 :
95 27 : CADGeometry::~CADGeometry()
96 : {
97 :
98 27 : }
99 :
100 13 : CADGeometry::GeometryType CADGeometry::getType() const
101 : {
102 13 : return geometryType;
103 : }
104 :
105 13 : double CADGeometry::getThickness() const
106 : {
107 13 : return m_thickness;
108 : }
109 :
110 13 : void CADGeometry::setThickness( double thickness )
111 : {
112 13 : m_thickness = thickness;
113 13 : }
114 :
115 13 : RGBColor CADGeometry::getColor() const
116 : {
117 13 : return geometry_color;
118 : }
119 :
120 17 : void CADGeometry::setColor( RGBColor color )
121 : {
122 17 : geometry_color = color;
123 17 : }
124 :
125 16 : vector<string> CADGeometry::getEED() const
126 : {
127 16 : return asEED;
128 : }
129 :
130 17 : void CADGeometry::setEED( const vector<string>& eed )
131 : {
132 17 : asEED = eed;
133 17 : }
134 :
135 13 : vector<CADAttrib> CADGeometry::getBlockAttributes() const
136 : {
137 13 : return blockAttributes;
138 : }
139 :
140 0 : void CADGeometry::setBlockAttributes( const vector<CADAttrib>& data )
141 : {
142 0 : blockAttributes = data;
143 0 : }
144 :
145 : //------------------------------------------------------------------------------
146 : // CADUnknown
147 : //------------------------------------------------------------------------------
148 0 : CADUnknown::CADUnknown()
149 : {
150 0 : }
151 :
152 0 : void CADUnknown::transform( const Matrix& /*matrix*/)
153 : {
154 0 : }
155 :
156 0 : void CADUnknown::print() const
157 : {
158 0 : cout << "|---------Unhandled---------|\n\n";
159 0 : }
160 :
161 : //------------------------------------------------------------------------------
162 : // CADPoint3D
163 : //------------------------------------------------------------------------------
164 :
165 16 : CADPoint3D::CADPoint3D() :
166 16 : xAxisAng( 0.0 )
167 : {
168 16 : geometryType = CADGeometry::POINT;
169 16 : }
170 :
171 2 : CADPoint3D::CADPoint3D( const CADVector& positionIn, double thicknessIn ) :
172 : position( positionIn),
173 2 : xAxisAng( 0.0 )
174 : {
175 2 : m_thickness = thicknessIn;
176 2 : geometryType = CADGeometry::POINT;
177 2 : }
178 :
179 32 : CADVector CADPoint3D::getPosition() const
180 : {
181 32 : return position;
182 : }
183 :
184 16 : void CADPoint3D::setPosition( const CADVector& value )
185 : {
186 16 : position = value;
187 16 : }
188 :
189 0 : CADVector CADPoint3D::getExtrusion() const
190 : {
191 0 : return extrusion;
192 : }
193 :
194 11 : void CADPoint3D::setExtrusion( const CADVector& value )
195 : {
196 11 : extrusion = value;
197 11 : }
198 :
199 0 : double CADPoint3D::getXAxisAng() const
200 : {
201 0 : return xAxisAng;
202 : }
203 :
204 3 : void CADPoint3D::setXAxisAng( double value )
205 : {
206 3 : xAxisAng = value;
207 3 : }
208 :
209 0 : void CADPoint3D::print() const
210 : {
211 : cout << "|---------Point---------|\n" <<
212 0 : "Position: \t" << position.getX() <<
213 0 : "\t" << position.getY() <<
214 0 : "\t" << position.getZ() << "\n\n";
215 0 : }
216 :
217 0 : void CADPoint3D::transform( const Matrix& matrix )
218 : {
219 0 : position = matrix.multiply( position );
220 0 : }
221 :
222 : //------------------------------------------------------------------------------
223 : // CADLine
224 : //------------------------------------------------------------------------------
225 :
226 0 : CADLine::CADLine()
227 : {
228 0 : geometryType = CADGeometry::LINE;
229 0 : }
230 :
231 1 : CADLine::CADLine( const CADPoint3D& startIn, const CADPoint3D& endIn ) :
232 : start( startIn ),
233 1 : end( endIn )
234 : {
235 1 : geometryType = CADGeometry::LINE;
236 1 : }
237 :
238 3 : CADPoint3D CADLine::getStart() const
239 : {
240 3 : return start;
241 : }
242 :
243 0 : void CADLine::setStart( const CADPoint3D& value )
244 : {
245 0 : start = value;
246 0 : }
247 :
248 3 : CADPoint3D CADLine::getEnd() const
249 : {
250 3 : return end;
251 : }
252 :
253 0 : void CADLine::setEnd( const CADPoint3D& value )
254 : {
255 0 : end = value;
256 0 : }
257 :
258 0 : void CADLine::print() const
259 : {
260 : cout << "|---------Line---------|\n" <<
261 0 : "Start Position: \t" << start.getPosition().getX() <<
262 0 : "\t" << start.getPosition().getY() <<
263 0 : "\t" << start.getPosition().getZ() << "\n" <<
264 0 : "End Position: \t" << end.getPosition().getX() <<
265 0 : "\t" << end.getPosition().getY() <<
266 0 : "\t" << end.getPosition().getZ() << "\n\n";
267 0 : }
268 :
269 0 : void CADLine::transform( const Matrix& matrix )
270 : {
271 0 : start.transform( matrix );
272 0 : end.transform( matrix );
273 0 : }
274 :
275 : //------------------------------------------------------------------------------
276 : // CADCircle
277 : //------------------------------------------------------------------------------
278 :
279 4 : CADCircle::CADCircle() : radius( 0.0f )
280 : {
281 4 : geometryType = CADGeometry::CIRCLE;
282 4 : }
283 :
284 12 : double CADCircle::getRadius() const
285 : {
286 12 : return radius;
287 : }
288 :
289 3 : void CADCircle::setRadius( double value )
290 : {
291 3 : radius = value;
292 3 : }
293 :
294 0 : void CADCircle::print() const
295 : {
296 : cout << "|---------Circle---------|\n" <<
297 0 : "Position: \t" << position.getX() <<
298 0 : "\t" << position.getY() <<
299 0 : "\t" << position.getZ() << "\n" <<
300 0 : "Radius: " << radius << "\n\n";
301 0 : }
302 :
303 : //------------------------------------------------------------------------------
304 : // CADArc
305 : //------------------------------------------------------------------------------
306 :
307 1 : CADArc::CADArc() : CADCircle(),
308 : startingAngle( 0.0f ),
309 1 : endingAngle( 0.0f )
310 : {
311 1 : geometryType = CADGeometry::ARC;
312 1 : }
313 :
314 1 : double CADArc::getStartingAngle() const
315 : {
316 1 : return startingAngle;
317 : }
318 :
319 1 : void CADArc::setStartingAngle( double value )
320 : {
321 1 : startingAngle = value;
322 1 : }
323 :
324 1 : double CADArc::getEndingAngle() const
325 : {
326 1 : return endingAngle;
327 : }
328 :
329 1 : void CADArc::setEndingAngle( double value )
330 : {
331 1 : endingAngle = value;
332 1 : }
333 :
334 0 : void CADArc::print() const
335 : {
336 : cout << "|---------Arc---------|\n" <<
337 0 : "Position: \t" << position.getX() <<
338 0 : "\t" << position.getY() <<
339 0 : "\t" << position.getZ() << "\n" <<
340 0 : "Radius: \t" << radius << "\n" <<
341 0 : "Beg & End angles: \t" << startingAngle <<
342 0 : "\t" << endingAngle << "\n\n";
343 0 : }
344 :
345 : //------------------------------------------------------------------------------
346 : // CADPolyline3D
347 : //------------------------------------------------------------------------------
348 :
349 0 : CADPolyline3D::CADPolyline3D()
350 : {
351 0 : geometryType = CADGeometry::POLYLINE3D;
352 0 : }
353 :
354 0 : void CADPolyline3D::addVertex( const CADVector& vertex )
355 : {
356 0 : vertices.push_back( vertex );
357 0 : }
358 :
359 0 : size_t CADPolyline3D::getVertexCount() const
360 : {
361 0 : return vertices.size();
362 : }
363 :
364 0 : CADVector& CADPolyline3D::getVertex( size_t index )
365 : {
366 0 : return vertices[index];
367 : }
368 :
369 0 : void CADPolyline3D::print() const
370 : {
371 0 : cout << "|------Polyline3D-----|\n";
372 0 : for( size_t i = 0; i < vertices.size(); ++i )
373 : {
374 0 : cout << " #" << i <<
375 0 : ". X: " << vertices[i].getX() <<
376 0 : ", Y: " << vertices[i].getY() << "\n";
377 : }
378 0 : cout << "\n";
379 0 : }
380 :
381 0 : void CADPolyline3D::transform( const Matrix& matrix )
382 : {
383 0 : for( CADVector& vertex : vertices )
384 : {
385 0 : vertex = matrix.multiply( vertex );
386 : }
387 0 : }
388 :
389 : //------------------------------------------------------------------------------
390 : // CADLWPolyline
391 : //------------------------------------------------------------------------------
392 :
393 0 : CADLWPolyline::CADLWPolyline() :
394 : bClosed( false ),
395 : constWidth( 0.0 ),
396 0 : elevation( 0.0 )
397 : {
398 0 : geometryType = CADGeometry::LWPOLYLINE;
399 0 : }
400 :
401 0 : void CADLWPolyline::print() const
402 : {
403 0 : cout << "|------LWPolyline-----|\n";
404 0 : for( size_t i = 0; i < vertices.size(); ++i )
405 : {
406 0 : cout << " #" << i <<
407 0 : ". X: " << vertices[i].getX() <<
408 0 : ", Y: " << vertices[i].getY() << "\n";
409 : }
410 0 : cout << "\n";
411 0 : }
412 :
413 0 : double CADLWPolyline::getConstWidth() const
414 : {
415 0 : return constWidth;
416 : }
417 :
418 0 : void CADLWPolyline::setConstWidth( double value )
419 : {
420 0 : constWidth = value;
421 0 : }
422 :
423 0 : double CADLWPolyline::getElevation() const
424 : {
425 0 : return elevation;
426 : }
427 :
428 0 : void CADLWPolyline::setElevation( double value )
429 : {
430 0 : elevation = value;
431 0 : }
432 :
433 0 : CADVector CADLWPolyline::getVectExtrusion() const
434 : {
435 0 : return vectExtrusion;
436 : }
437 :
438 0 : void CADLWPolyline::setVectExtrusion( const CADVector& value )
439 : {
440 0 : vectExtrusion = value;
441 0 : }
442 :
443 0 : vector<pair<double, double> > CADLWPolyline::getWidths() const
444 : {
445 0 : return widths;
446 : }
447 :
448 0 : void CADLWPolyline::setWidths( const vector<pair<double, double> >& value )
449 : {
450 0 : widths = value;
451 0 : }
452 :
453 0 : vector<double> CADLWPolyline::getBulges() const
454 : {
455 0 : return bulges;
456 : }
457 :
458 0 : void CADLWPolyline::setBulges( const vector<double>& value )
459 : {
460 0 : bulges = value;
461 0 : }
462 :
463 0 : bool CADLWPolyline::isClosed() const
464 : {
465 0 : return bClosed;
466 : }
467 :
468 0 : void CADLWPolyline::setClosed( bool state )
469 : {
470 0 : bClosed = state;
471 0 : }
472 :
473 : //------------------------------------------------------------------------------
474 : // CADEllipse
475 : //------------------------------------------------------------------------------
476 :
477 1 : CADEllipse::CADEllipse() : CADArc(),
478 1 : axisRatio( 0.0f )
479 : {
480 1 : geometryType = CADGeometry::ELLIPSE;
481 1 : }
482 :
483 1 : double CADEllipse::getAxisRatio() const
484 : {
485 1 : return axisRatio;
486 : }
487 :
488 1 : void CADEllipse::setAxisRatio( double value )
489 : {
490 1 : axisRatio = value;
491 1 : }
492 :
493 1 : CADVector CADEllipse::getSMAxis()
494 : {
495 1 : return vectSMAxis;
496 : }
497 :
498 1 : void CADEllipse::setSMAxis( const CADVector& SMAxisVect )
499 : {
500 1 : vectSMAxis = SMAxisVect;
501 1 : }
502 :
503 0 : void CADEllipse::print() const
504 : {
505 : cout << "|---------Ellipse---------|\n" <<
506 0 : "Position: \t" << position.getX() <<
507 0 : "\t" << position.getY() <<
508 0 : "\t" << position.getZ() << "\n" <<
509 0 : "Beg & End angles: \t" << startingAngle <<
510 0 : "\t" << endingAngle << "\n\n";
511 0 : }
512 :
513 : //------------------------------------------------------------------------------
514 : // CADText
515 : //------------------------------------------------------------------------------
516 :
517 11 : CADText::CADText() : CADPoint3D(),
518 : obliqueAngle( 0 ),
519 : rotationAngle( 0 ),
520 11 : height( 0 )
521 : {
522 11 : geometryType = CADGeometry::TEXT;
523 11 : }
524 :
525 6 : string CADText::getTextValue() const
526 : {
527 6 : return textValue;
528 : }
529 :
530 11 : void CADText::setTextValue( const string& value )
531 : {
532 11 : textValue = value;
533 11 : }
534 :
535 0 : double CADText::getHeight() const
536 : {
537 0 : return height;
538 : }
539 :
540 11 : void CADText::setHeight( double value )
541 : {
542 11 : height = value;
543 11 : }
544 :
545 0 : double CADText::getRotationAngle() const
546 : {
547 0 : return rotationAngle;
548 : }
549 :
550 9 : void CADText::setRotationAngle( double value )
551 : {
552 9 : rotationAngle = value;
553 9 : }
554 :
555 0 : double CADText::getObliqueAngle() const
556 : {
557 0 : return obliqueAngle;
558 : }
559 :
560 9 : void CADText::setObliqueAngle( double value )
561 : {
562 9 : obliqueAngle = value;
563 9 : }
564 :
565 0 : void CADText::print() const
566 : {
567 : cout << "|---------Text---------|\n" <<
568 0 : "Position: \t" << position.getX() <<
569 0 : "\t" << position.getY() << "\n" <<
570 0 : "Text value: \t" << textValue << "\n\n";
571 0 : }
572 :
573 : //------------------------------------------------------------------------------
574 : // CADRay
575 : //------------------------------------------------------------------------------
576 :
577 0 : CADRay::CADRay() : CADPoint3D()
578 : {
579 0 : geometryType = CADGeometry::RAY;
580 0 : }
581 :
582 0 : CADVector CADRay::getVectVector() const
583 : {
584 0 : return extrusion;
585 : }
586 :
587 0 : void CADRay::setVectVector( const CADVector& value )
588 : {
589 0 : extrusion = value;
590 0 : }
591 :
592 0 : void CADRay::print() const
593 : {
594 : cout << "|---------Ray---------|\n" <<
595 0 : "Position: \t" << position.getX() <<
596 0 : "\t" << position.getY() << "\n" <<
597 0 : "Vector: \t" << extrusion.getX() <<
598 0 : "\t" << extrusion.getY() << "\n\n";
599 0 : }
600 :
601 : //------------------------------------------------------------------------------
602 : // CADHatch
603 : //------------------------------------------------------------------------------
604 :
605 0 : CADHatch::CADHatch()
606 : {
607 0 : geometryType = CADGeometry::HATCH;
608 0 : }
609 :
610 : //------------------------------------------------------------------------------
611 : // CADSpline
612 : //------------------------------------------------------------------------------
613 :
614 0 : CADSpline::CADSpline() :
615 : scenario( 0 ),
616 : rational( false ),
617 : closed( false ),
618 : weight( false ),
619 : fitTolerance( 0.0 ),
620 0 : degree( 0 )
621 : {
622 0 : geometryType = CADGeometry::SPLINE;
623 0 : }
624 :
625 0 : void CADSpline::print() const
626 : {
627 :
628 : cout << "|---------Spline---------|\n" <<
629 0 : "Is rational: \t" << rational << "\n" <<
630 0 : "Is closed: \t" << closed << "\n" <<
631 0 : "Control pts count: " << avertCtrlPoints.size() << "\n";
632 0 : for( size_t j = 0; j < avertCtrlPoints.size(); ++j )
633 : {
634 0 : cout << " #" << j << ".\t" << avertCtrlPoints[j].getX() <<
635 0 : "\t" << avertCtrlPoints[j].getY() <<
636 0 : "\t" << avertCtrlPoints[j].getZ() << "\t";
637 0 : if( weight == true )
638 0 : cout << ctrlPointsWeight[j] << "\n";
639 : else
640 0 : cout << "\n";
641 : }
642 :
643 0 : cout << "Fit pts count: " << averFitPoints.size() << "\n";
644 0 : for( size_t j = 0; j < averFitPoints.size(); ++j )
645 : {
646 0 : cout << " #" << j << ".\t" << averFitPoints[j].getX() <<
647 0 : "\t" << averFitPoints[j].getY() <<
648 0 : "\t" << averFitPoints[j].getZ() << "\n";
649 : }
650 0 : cout << "\n";
651 0 : }
652 :
653 0 : void CADSpline::transform( const Matrix& matrix )
654 : {
655 0 : for( CADVector& pt : avertCtrlPoints )
656 0 : pt = matrix.multiply( pt );
657 0 : for( CADVector& pt : averFitPoints )
658 0 : pt = matrix.multiply( pt );
659 0 : }
660 :
661 0 : long CADSpline::getScenario() const
662 : {
663 0 : return scenario;
664 : }
665 :
666 0 : void CADSpline::setScenario( long value )
667 : {
668 0 : scenario = value;
669 0 : }
670 :
671 0 : bool CADSpline::isRational() const
672 : {
673 0 : return rational;
674 : }
675 :
676 0 : void CADSpline::setRational( bool value )
677 : {
678 0 : rational = value;
679 0 : }
680 :
681 0 : bool CADSpline::isClosed() const
682 : {
683 0 : return closed;
684 : }
685 :
686 0 : void CADSpline::setClosed( bool value )
687 : {
688 0 : closed = value;
689 0 : }
690 :
691 0 : void CADSpline::addControlPointsWeight( double p_weight )
692 : {
693 0 : ctrlPointsWeight.push_back( p_weight );
694 0 : }
695 :
696 0 : void CADSpline::addControlPoint( const CADVector& point )
697 : {
698 0 : avertCtrlPoints.push_back( point );
699 0 : }
700 :
701 0 : void CADSpline::addFitPoint( const CADVector& point )
702 : {
703 0 : averFitPoints.push_back( point );
704 0 : }
705 :
706 0 : bool CADSpline::getWeight() const
707 : {
708 0 : return weight;
709 : }
710 :
711 0 : void CADSpline::setWeight( bool value )
712 : {
713 0 : weight = value;
714 0 : }
715 :
716 0 : double CADSpline::getFitTolerance() const
717 : {
718 0 : return fitTolerance;
719 : }
720 :
721 0 : void CADSpline::setFitTolerance( double value )
722 : {
723 0 : fitTolerance = value;
724 0 : }
725 :
726 0 : long CADSpline::getDegree() const
727 : {
728 0 : return degree;
729 : }
730 :
731 0 : void CADSpline::setDegree( long value )
732 : {
733 0 : degree = value;
734 0 : }
735 :
736 0 : vector<CADVector>& CADSpline::getControlPoints()
737 : {
738 0 : return avertCtrlPoints;
739 : }
740 :
741 0 : vector<CADVector>& CADSpline::getFitPoints()
742 : {
743 0 : return averFitPoints;
744 : }
745 :
746 0 : vector<double>& CADSpline::getControlPointsWeights()
747 : {
748 0 : return ctrlPointsWeight;
749 : }
750 :
751 : //------------------------------------------------------------------------------
752 : // CADSolid
753 : //------------------------------------------------------------------------------
754 :
755 0 : CADSolid::CADSolid() :
756 0 : elevation( 0.0 )
757 : {
758 0 : geometryType = CADGeometry::SOLID;
759 0 : }
760 :
761 0 : void CADSolid::print() const
762 : {
763 0 : cout << "|---------Solid---------|\n";
764 0 : for( size_t i = 0; i < avertCorners.size(); ++i )
765 : {
766 0 : cout << " #" << i << ".\t" << avertCorners[i].getX() <<
767 0 : "\t" << avertCorners[i].getY() << "\n" <<
768 0 : "Elevation: " << elevation << "\n";
769 : }
770 0 : cout << "\n";
771 0 : }
772 :
773 0 : void CADSolid::transform( const Matrix& matrix )
774 : {
775 0 : CADPoint3D::transform( matrix );
776 0 : for( CADVector& corner : avertCorners )
777 0 : corner = matrix.multiply( corner );
778 0 : }
779 :
780 0 : double CADSolid::getElevation() const
781 : {
782 0 : return elevation;
783 : }
784 :
785 0 : void CADSolid::setElevation( double value )
786 : {
787 0 : elevation = value;
788 0 : }
789 :
790 0 : void CADSolid::addCorner( const CADVector& corner )
791 : {
792 0 : avertCorners.push_back( corner );
793 0 : }
794 :
795 0 : vector<CADVector> CADSolid::getCorners()
796 : {
797 0 : return avertCorners;
798 : }
799 :
800 : //------------------------------------------------------------------------------
801 : // CADImage
802 : //------------------------------------------------------------------------------
803 :
804 0 : CADImage::CADImage() :
805 : bTransparency( false ),
806 : bClipping( false ),
807 : dBrightness( 0 ),
808 : dContrast( 0 ),
809 : resolutionUnits( NONE ),
810 0 : clippingBoundaryType( 0 )
811 : {
812 0 : geometryType = CADGeometry::IMAGE;
813 0 : }
814 :
815 0 : CADVector CADImage::getVertInsertionPoint() const
816 : {
817 0 : return vertInsertionPoint;
818 : }
819 :
820 0 : void CADImage::setVertInsertionPoint( const CADVector& value )
821 : {
822 0 : vertInsertionPoint = value;
823 0 : }
824 :
825 0 : CADVector CADImage::getImageSize() const
826 : {
827 0 : return imageSize;
828 : }
829 :
830 0 : void CADImage::setImageSize( const CADVector& value )
831 : {
832 0 : imageSize = value;
833 0 : }
834 :
835 0 : CADVector CADImage::getImageSizeInPx() const
836 : {
837 0 : return imageSizeInPx;
838 : }
839 :
840 0 : void CADImage::setImageSizeInPx( const CADVector& value )
841 : {
842 0 : imageSizeInPx = value;
843 0 : }
844 :
845 0 : CADVector CADImage::getPixelSizeInACADUnits() const
846 : {
847 0 : return pixelSizeInACADUnits;
848 : }
849 :
850 0 : void CADImage::setPixelSizeInACADUnits( const CADVector& value )
851 : {
852 0 : pixelSizeInACADUnits = value;
853 0 : }
854 :
855 0 : short CADImage::getClippingBoundaryType() const
856 : {
857 0 : return clippingBoundaryType;
858 : }
859 :
860 0 : void CADImage::setClippingBoundaryType( short value )
861 : {
862 0 : clippingBoundaryType = value;
863 0 : }
864 :
865 0 : enum CADImage::ResolutionUnit CADImage::getResolutionUnits() const
866 : {
867 0 : return resolutionUnits;
868 : }
869 :
870 0 : void CADImage::setResolutionUnits( enum CADImage::ResolutionUnit res_unit )
871 : {
872 0 : resolutionUnits = res_unit;
873 0 : }
874 :
875 0 : string CADImage::getFilePath() const
876 : {
877 0 : return filePath;
878 : }
879 :
880 0 : void CADImage::setFilePath( const string& value )
881 : {
882 0 : filePath = value;
883 0 : }
884 :
885 0 : void CADImage::setOptions( bool transparency, bool clip, unsigned char brightness,
886 : unsigned char contrast )
887 : {
888 0 : bTransparency = transparency;
889 0 : bClipping = clip;
890 0 : dBrightness = brightness;
891 0 : dContrast = contrast;
892 0 : }
893 :
894 0 : void CADImage::print() const
895 : {
896 : cout << "|---------Image---------|\n" <<
897 0 : "Filepath: " << filePath << "\n" <<
898 0 : "Insertion point: " << vertInsertionPoint.getX() << "\t" <<
899 0 : vertInsertionPoint.getY() << "\n" <<
900 0 : "Transparent? : " << bTransparency << "\n" <<
901 0 : "Brightness (0-100) : " << dBrightness << "\n" <<
902 0 : "Contrast (0-100) : " << dContrast << "\n" <<
903 0 : "Clipping polygon:" << endl;
904 0 : for( size_t i = 0; i < avertClippingPolygon.size(); ++i )
905 : {
906 0 : cout << " #" << i << ". X: " << avertClippingPolygon[i].getX() <<
907 0 : ", Y: " << avertClippingPolygon[i].getY() << "\n";
908 : }
909 0 : cout << "\n";
910 0 : }
911 :
912 0 : void CADImage::transform( const Matrix& matrix )
913 : {
914 0 : vertInsertionPoint = matrix.multiply( vertInsertionPoint );
915 0 : for( CADVector& pt : avertClippingPolygon )
916 0 : pt = matrix.multiply( pt );
917 0 : }
918 :
919 0 : void CADImage::addClippingPoint( const CADVector& pt )
920 : {
921 0 : avertClippingPolygon.push_back( pt );
922 0 : }
923 :
924 : //------------------------------------------------------------------------------
925 : // CADMText
926 : //------------------------------------------------------------------------------
927 :
928 2 : CADMText::CADMText() :
929 : rectWidth( 0.0 ),
930 : extents( 0.0 ),
931 2 : extentsWidth( 0.0 )
932 : {
933 2 : geometryType = CADGeometry::MTEXT;
934 2 : }
935 :
936 0 : double CADMText::getRectWidth() const
937 : {
938 0 : return rectWidth;
939 : }
940 :
941 2 : void CADMText::setRectWidth( double value )
942 : {
943 2 : rectWidth = value;
944 2 : }
945 :
946 0 : double CADMText::getExtents() const
947 : {
948 0 : return extents;
949 : }
950 :
951 2 : void CADMText::setExtents( double value )
952 : {
953 2 : extents = value;
954 2 : }
955 :
956 0 : double CADMText::getExtentsWidth() const
957 : {
958 0 : return extentsWidth;
959 : }
960 :
961 2 : void CADMText::setExtentsWidth( double value )
962 : {
963 2 : extentsWidth = value;
964 2 : }
965 :
966 0 : void CADMText::print() const
967 : {
968 : cout << "|---------MText---------|\n" <<
969 0 : "Position: " << position.getX() << "\t" <<
970 0 : position.getY() << "\t" <<
971 0 : position.getZ() << "\n" <<
972 0 : "Text: " << textValue << "\n\n";
973 0 : }
974 :
975 : //------------------------------------------------------------------------------
976 : // CADFace3D
977 : //------------------------------------------------------------------------------
978 :
979 0 : CADFace3D::CADFace3D() :
980 0 : invisFlags( 0 )
981 : {
982 0 : geometryType = CADGeometry::FACE3D;
983 0 : }
984 :
985 0 : void CADFace3D::addCorner( const CADVector& corner )
986 : {
987 0 : avertCorners.push_back( corner );
988 0 : }
989 :
990 0 : CADVector CADFace3D::getCorner( size_t index )
991 : {
992 0 : return avertCorners[index];
993 : }
994 :
995 0 : void CADFace3D::print() const
996 : {
997 : cout << "|---------3DFace---------|\n" <<
998 0 : "Corners: \n";
999 0 : for( size_t i = 0; i < avertCorners.size(); ++i )
1000 : {
1001 0 : cout << " #" << i << ". X: " << avertCorners[i].getX() << "\t" <<
1002 0 : "Y: " << avertCorners[i].getY() << "\t" <<
1003 0 : "Z: " << avertCorners[i].getZ() << "\n";
1004 : }
1005 0 : cout << "\n";
1006 0 : }
1007 :
1008 0 : void CADFace3D::transform( const Matrix& matrix )
1009 : {
1010 0 : for( CADVector& corner : avertCorners )
1011 : {
1012 0 : corner = matrix.multiply( corner );
1013 : }
1014 0 : }
1015 :
1016 0 : short CADFace3D::getInvisFlags() const
1017 : {
1018 0 : return invisFlags;
1019 : }
1020 :
1021 0 : void CADFace3D::setInvisFlags( short value )
1022 : {
1023 0 : invisFlags = value;
1024 0 : }
1025 :
1026 : //------------------------------------------------------------------------------
1027 : // CADPolylinePFace
1028 : //------------------------------------------------------------------------------
1029 :
1030 0 : CADPolylinePFace::CADPolylinePFace()
1031 : {
1032 0 : geometryType = CADGeometry::POLYLINE_PFACE;
1033 0 : }
1034 :
1035 0 : void CADPolylinePFace::print() const
1036 : {
1037 0 : cout << "|---------PolylinePface---------|\n";
1038 0 : for( size_t i = 0; i < vertices.size(); ++i )
1039 : {
1040 0 : cout << " #" << i << ".\t" << vertices[i].getX() <<
1041 0 : "\t" << vertices[i].getY() <<
1042 0 : "\t" << vertices[i].getZ() << "\n";
1043 : }
1044 0 : cout << "\n";
1045 0 : }
1046 :
1047 0 : void CADPolylinePFace::transform( const Matrix& matrix )
1048 : {
1049 0 : for( CADVector& vertex : vertices )
1050 0 : vertex = matrix.multiply( vertex );
1051 0 : }
1052 :
1053 0 : void CADPolylinePFace::addVertex( const CADVector& vertex )
1054 : {
1055 0 : vertices.push_back( vertex );
1056 0 : }
1057 :
1058 : //------------------------------------------------------------------------------
1059 : // CADXLine
1060 : //------------------------------------------------------------------------------
1061 :
1062 0 : CADXLine::CADXLine()
1063 : {
1064 0 : geometryType = CADGeometry::XLINE;
1065 0 : }
1066 :
1067 0 : void CADXLine::print() const
1068 : {
1069 : cout << "|---------XLine---------|\n" <<
1070 0 : "Position: " << position.getX() << "\t" <<
1071 0 : position.getY() << "\t" <<
1072 0 : position.getZ() << "\n" <<
1073 0 : "Direction: " << extrusion.getX() << "\t" <<
1074 0 : extrusion.getY() << "\t" <<
1075 0 : extrusion.getZ() << "\n\n";
1076 0 : }
1077 :
1078 : //------------------------------------------------------------------------------
1079 : // CADMLine
1080 : //------------------------------------------------------------------------------
1081 :
1082 0 : CADMLine::CADMLine() :
1083 : scale( 0.0 ),
1084 0 : opened( false )
1085 : {
1086 0 : geometryType = CADGeometry::MLINE;
1087 0 : }
1088 :
1089 0 : void CADMLine::print() const
1090 : {
1091 : cout << "|---------MLine---------|\n" <<
1092 0 : "Base point: " << position.getX() << "\t" <<
1093 0 : position.getY() << "\t" <<
1094 0 : position.getZ() << "\n" <<
1095 0 : "Vertices:\n";
1096 0 : for( size_t i = 0; i < avertVertices.size(); ++i )
1097 : {
1098 0 : cout << " #" << i << ".\t" << avertVertices[i].getX() <<
1099 0 : "\t" << avertVertices[i].getY() <<
1100 0 : "\t" << avertVertices[i].getZ() << "\n";
1101 : }
1102 0 : cout << "\n";
1103 0 : }
1104 :
1105 0 : void CADMLine::transform( const Matrix& matrix )
1106 : {
1107 0 : CADPoint3D::transform( matrix );
1108 0 : for( CADVector& vertex : avertVertices )
1109 : {
1110 0 : vertex = matrix.multiply( vertex );
1111 : }
1112 0 : }
1113 :
1114 0 : double CADMLine::getScale() const
1115 : {
1116 0 : return scale;
1117 : }
1118 :
1119 0 : void CADMLine::setScale( double value )
1120 : {
1121 0 : scale = value;
1122 0 : }
1123 :
1124 0 : bool CADMLine::isOpened() const
1125 : {
1126 0 : return opened;
1127 : }
1128 :
1129 0 : void CADMLine::setOpened( bool value )
1130 : {
1131 0 : opened = value;
1132 0 : }
1133 :
1134 0 : void CADMLine::addVertex( const CADVector& vertex )
1135 : {
1136 0 : avertVertices.push_back( vertex );
1137 0 : }
1138 :
1139 : //------------------------------------------------------------------------------
1140 : // CADAttrib
1141 : //------------------------------------------------------------------------------
1142 :
1143 5 : CADAttrib::CADAttrib() :
1144 : dfElevation( 0.0 ),
1145 5 : bLockPosition( false )
1146 : {
1147 5 : geometryType = CADGeometry::ATTRIB;
1148 5 : }
1149 :
1150 0 : void CADAttrib::print() const
1151 : {
1152 : cout << "|---------Attribute---------|\n" <<
1153 0 : "Base point: " << position.getX() << "\t" <<
1154 0 : position.getY() << "\t" <<
1155 0 : position.getZ() << "\n" <<
1156 0 : "Tag: " << sTag << "\n" <<
1157 0 : "Text: " << textValue << "\n\n";
1158 0 : }
1159 :
1160 0 : void CADAttrib::transform( const Matrix& matrix )
1161 : {
1162 0 : CADText::transform( matrix );
1163 0 : vertAlignmentPoint = matrix.multiply( vertAlignmentPoint );
1164 0 : }
1165 :
1166 0 : double CADAttrib::getElevation() const
1167 : {
1168 0 : return dfElevation;
1169 : }
1170 :
1171 5 : void CADAttrib::setElevation( double elev )
1172 : {
1173 5 : dfElevation = elev;
1174 5 : }
1175 :
1176 5 : string CADAttrib::getTag() const
1177 : {
1178 5 : return sTag;
1179 : }
1180 :
1181 5 : void CADAttrib::setTag( const string& tag )
1182 : {
1183 5 : sTag = tag;
1184 5 : }
1185 :
1186 0 : CADVector CADAttrib::getAlignmentPoint() const
1187 : {
1188 0 : return vertAlignmentPoint;
1189 : }
1190 :
1191 5 : void CADAttrib::setAlignmentPoint( const CADVector& vect )
1192 : {
1193 5 : vertAlignmentPoint = vect;
1194 5 : }
1195 :
1196 0 : bool CADAttrib::isPositionLocked() const
1197 : {
1198 0 : return bLockPosition;
1199 : }
1200 :
1201 5 : void CADAttrib::setPositionLocked( bool lock )
1202 : {
1203 5 : bLockPosition = lock;
1204 5 : }
1205 :
1206 : //------------------------------------------------------------------------------
1207 : // CADAttdef
1208 : //------------------------------------------------------------------------------
1209 :
1210 5 : CADAttdef::CADAttdef()
1211 : {
1212 5 : geometryType = CADGeometry::ATTDEF;
1213 5 : }
1214 :
1215 0 : void CADAttdef::print() const
1216 : {
1217 : cout << "|---------Attribute defn---------|\n" <<
1218 0 : "Base point: " << position.getX() << "\t" <<
1219 0 : position.getY() << "\t" <<
1220 0 : position.getZ() << "\n" <<
1221 0 : "Tag: " << sTag << "\n" <<
1222 0 : "Text: " << textValue << "\n" <<
1223 0 : "Prompt: " << sPrompt << "\n\n";
1224 0 : }
1225 :
1226 0 : string CADAttdef::getPrompt() const
1227 : {
1228 0 : return sPrompt;
1229 : }
1230 :
1231 5 : void CADAttdef::setPrompt( const string& prompt )
1232 : {
1233 5 : sPrompt = prompt;
1234 5 : }
|
