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