1 /******************************************************************************
2 ** libDXFrw - Library to read/write DXF files (ascii & binary) **
3 ** **
4 ** Copyright (C) 2011-2015 José F. Soriano, rallazz@gmail.com **
5 ** **
6 ** This library is free software, licensed under the terms of the GNU **
7 ** General Public License as published by the Free Software Foundation, **
8 ** either version 2 of the License, or (at your option) any later version. **
9 ** You should have received a copy of the GNU General Public License **
10 ** along with this program. If not, see <http://www.gnu.org/licenses/>. **
11 ******************************************************************************/
12
13 #include <cstdlib>
14 #include "drw_entities.h"
15 #include "intern/dxfreader.h"
16 #include "intern/drw_dbg.h"
17 #include "../vmisc/diagnostic.h"
18
19
20 //! Calculate arbitary axis
21 /*!
22 * Calculate arbitary axis for apply extrusions
23 * @author Rallaz
24 */
calculateAxis(DRW_Coord extPoint)25 void DRW_Entity::calculateAxis(DRW_Coord extPoint){
26 //Follow the arbitrary DXF definitions for extrusion axes.
27 if (fabs(extPoint.x) < 0.015625 && fabs(extPoint.y) < 0.015625) {
28 //If we get here, implement Ax = Wy x N where Wy is [0,1,0] per the DXF spec.
29 //The cross product works out to Wy.y*N.z-Wy.z*N.y, Wy.z*N.x-Wy.x*N.z, Wy.x*N.y-Wy.y*N.x
30 //Factoring in the fixed values for Wy gives N.z,0,-N.x
31 extAxisX.x = extPoint.z;
32 extAxisX.y = 0;
33 extAxisX.z = -extPoint.x;
34 } else {
35 //Otherwise, implement Ax = Wz x N where Wz is [0,0,1] per the DXF spec.
36 //The cross product works out to Wz.y*N.z-Wz.z*N.y, Wz.z*N.x-Wz.x*N.z, Wz.x*N.y-Wz.y*N.x
37 //Factoring in the fixed values for Wz gives -N.y,N.x,0.
38 extAxisX.x = -extPoint.y;
39 extAxisX.y = extPoint.x;
40 extAxisX.z = 0;
41 }
42
43 extAxisX.unitize();
44
45 //Ay = N x Ax
46 extAxisY.x = (extPoint.y * extAxisX.z) - (extAxisX.y * extPoint.z);
47 extAxisY.y = (extPoint.z * extAxisX.x) - (extAxisX.z * extPoint.x);
48 extAxisY.z = (extPoint.x * extAxisX.y) - (extAxisX.x * extPoint.y);
49
50 extAxisY.unitize();
51 }
52
53 //! Extrude a point using arbitary axis
54 /*!
55 * apply extrusion in a point using arbitary axis (previous calculated)
56 * @author Rallaz
57 */
extrudePoint(DRW_Coord extPoint,DRW_Coord * point) const58 void DRW_Entity::extrudePoint(DRW_Coord extPoint, DRW_Coord *point) const{
59 double px, py, pz;
60 px = (extAxisX.x*point->x)+(extAxisY.x*point->y)+(extPoint.x*point->z);
61 py = (extAxisX.y*point->x)+(extAxisY.y*point->y)+(extPoint.y*point->z);
62 pz = (extAxisX.z*point->x)+(extAxisY.z*point->y)+(extPoint.z*point->z);
63
64 point->x = px;
65 point->y = py;
66 point->z = pz;
67 }
68
parseCode(int code,dxfReader * reader)69 bool DRW_Entity::parseCode(int code, dxfReader *reader){
70 switch (code) {
71 case 5:
72 handle = static_cast<quint32>(reader->getHandleString());
73 break;
74 case 330:
75 parentHandle = static_cast<quint32>(reader->getHandleString());
76 break;
77 case 8:
78 layer = reader->getUtf8String();
79 break;
80 case 6:
81 lineType = reader->getUtf8String();
82 break;
83 case 62:
84 color = reader->getInt32();
85 break;
86 case 370:
87 lWeight = DRW_LW_Conv::dxfInt2lineWidth(reader->getInt32());
88 break;
89 case 48:
90 ltypeScale = reader->getDouble();
91 break;
92 case 60:
93 visible = reader->getBool();
94 break;
95 case 420:
96 color24 = reader->getInt32();
97 break;
98 case 430:
99 colorName = reader->getString();
100 break;
101 case 67:
102 space = static_cast<DRW::Space>(reader->getInt32());
103 break;
104 case 102:
105 parseDxfGroups(code, reader);
106 break;
107 case 1000:
108 case 1001:
109 case 1002:
110 case 1003:
111 case 1004:
112 case 1005:
113 extData.push_back(new DRW_Variant(code, reader->getString()));
114 break;
115 case 1010:
116 case 1011:
117 case 1012:
118 case 1013:
119 curr = new DRW_Variant();
120 curr->addCoord();
121 curr->setCoordX(reader->getDouble());
122 curr->code = code;
123 extData.push_back(curr);
124 break;
125 case 1020:
126 case 1021:
127 case 1022:
128 case 1023:
129 if (curr)
130 curr->setCoordY(reader->getDouble());
131 break;
132 case 1030:
133 case 1031:
134 case 1032:
135 case 1033:
136 if (curr)
137 curr->setCoordZ(reader->getDouble());
138 curr=nullptr;
139 break;
140 case 1040:
141 case 1041:
142 case 1042:
143 extData.push_back(new DRW_Variant(code, reader->getDouble() ));
144 break;
145 case 1070:
146 case 1071:
147 extData.push_back(new DRW_Variant(code, reader->getInt32() ));
148 break;
149 default:
150 break;
151 }
152 return true;
153 }
154
155 //parses dxf 102 groups to read entity
parseDxfGroups(int code,dxfReader * reader)156 bool DRW_Entity::parseDxfGroups(int code, dxfReader *reader){
157 std::list<DRW_Variant> ls;
158 DRW_Variant curr;
159 int nc;
160 std::string appName= reader->getString();
161 if (!appName.empty() && appName.at(0)== '{'){
162 curr.addString(appName.substr(1, static_cast<size_t>(appName.size()-1)));
163 curr.code = code;
164 ls.push_back(curr);
165 while (code !=102 && appName.at(0)== '}'){
166 reader->readRec(&nc);
167 curr.code = code;
168 if (code == 330 || code == 360)
169 curr.addInt(reader->getHandleString());
170 else {
171 switch (reader->type) {
172 case dxfReader::STRING:
173 curr.addString(reader->getString());
174 break;
175 case dxfReader::INT32:
176 case dxfReader::INT64:
177 curr.addInt(reader->getInt32());
178 break;
179 case dxfReader::DOUBLE:
180 curr.addDouble(reader->getDouble());
181 break;
182 case dxfReader::BOOL:
183 curr.addInt(reader->getInt32());
184 break;
185 default:
186 break;
187 }
188 }
189 ls.push_back(curr);
190 }
191 }
192
193 appData.push_back(ls);
194 return true;
195 }
196
parseCode(int code,dxfReader * reader)197 void DRW_Point::parseCode(int code, dxfReader *reader){
198 switch (code) {
199 case 10:
200 basePoint.x = reader->getDouble();
201 break;
202 case 20:
203 basePoint.y = reader->getDouble();
204 break;
205 case 30:
206 basePoint.z = reader->getDouble();
207 break;
208 case 39:
209 thickness = reader->getDouble();
210 break;
211 case 210:
212 haveExtrusion = true;
213 extPoint.x = reader->getDouble();
214 break;
215 case 220:
216 extPoint.y = reader->getDouble();
217 break;
218 case 230:
219 extPoint.z = reader->getDouble();
220 break;
221 default:
222 DRW_Entity::parseCode(code, reader);
223 break;
224 }
225 }
226
parseCode(int code,dxfReader * reader)227 void DRW_ASTMNotch::parseCode(int code, dxfReader *reader)
228 {
229 switch (code) {
230 case 50:
231 angle = reader->getDouble();
232 break;
233 default:
234 DRW_Point::parseCode(code, reader);
235 break;
236 }
237 }
238
parseCode(int code,dxfReader * reader)239 void DRW_Line::parseCode(int code, dxfReader *reader){
240 switch (code) {
241 case 11:
242 secPoint.x = reader->getDouble();
243 break;
244 case 21:
245 secPoint.y = reader->getDouble();
246 break;
247 case 31:
248 secPoint.z = reader->getDouble();
249 break;
250 default:
251 DRW_Point::parseCode(code, reader);
252 break;
253 }
254 }
255
applyExtrusion()256 void DRW_Circle::applyExtrusion(){
257 if (haveExtrusion) {
258 //NOTE: Commenting these out causes the the arcs being tested to be located
259 //on the other side of the y axis (all x dimensions are negated).
260 calculateAxis(extPoint);
261 extrudePoint(extPoint, &basePoint);
262 }
263 }
264
parseCode(int code,dxfReader * reader)265 void DRW_Circle::parseCode(int code, dxfReader *reader){
266 switch (code) {
267 case 40:
268 radious = reader->getDouble();
269 break;
270 default:
271 DRW_Point::parseCode(code, reader);
272 break;
273 }
274 }
275
applyExtrusion()276 void DRW_Arc::applyExtrusion(){
277 DRW_Circle::applyExtrusion();
278
279 if(haveExtrusion){
280 // If the extrusion vector has a z value less than 0, the angles for the arc
281 // have to be mirrored since DXF files use the right hand rule.
282 // Note that the following code only handles the special case where there is a 2D
283 // drawing with the z axis heading into the paper (or rather screen). An arbitrary
284 // extrusion axis (with x and y values greater than 1/64) may still have issues.
285 if (fabs(extPoint.x) < 0.015625 && fabs(extPoint.y) < 0.015625 && extPoint.z < 0.0) {
286 staangle=M_PI-staangle;
287 endangle=M_PI-endangle;
288
289 double temp = staangle;
290 staangle=endangle;
291 endangle=temp;
292 }
293 }
294 }
295
parseCode(int code,dxfReader * reader)296 void DRW_Arc::parseCode(int code, dxfReader *reader){
297 switch (code) {
298 case 50:
299 staangle = reader->getDouble()/ ARAD;
300 break;
301 case 51:
302 endangle = reader->getDouble()/ ARAD;
303 break;
304 default:
305 DRW_Circle::parseCode(code, reader);
306 break;
307 }
308 }
309
parseCode(int code,dxfReader * reader)310 void DRW_Ellipse::parseCode(int code, dxfReader *reader){
311 switch (code) {
312 case 40:
313 ratio = reader->getDouble();
314 break;
315 case 41:
316 staparam = reader->getDouble();
317 break;
318 case 42:
319 endparam = reader->getDouble();
320 break;
321 default:
322 DRW_Line::parseCode(code, reader);
323 break;
324 }
325 }
326
applyExtrusion()327 void DRW_Ellipse::applyExtrusion(){
328 if (haveExtrusion) {
329 calculateAxis(extPoint);
330 extrudePoint(extPoint, &secPoint);
331 double intialparam = staparam;
332 if (extPoint.z < 0.){
333 staparam = M_PIx2 - endparam;
334 endparam = M_PIx2 - intialparam;
335 }
336 }
337 }
338
339 //if ratio > 1 minor axis are greather than major axis, correct it
correctAxis()340 void DRW_Ellipse::correctAxis(){
341 bool complete = false;
342 if (DRW_FuzzyComparePossibleNulls(staparam, endparam)) {
343 staparam = 0.0;
344 endparam = M_PIx2; //2*M_PI;
345 complete = true;
346 }
347 if (ratio > 1){
348 if ( fabs(endparam - staparam - M_PIx2) < 1.0e-10)
349 complete = true;
350 double incX = secPoint.x;
351 secPoint.x = -(secPoint.y * ratio);
352 secPoint.y = incX*ratio;
353 ratio = 1/ratio;
354 if (!complete){
355 if (staparam < M_PI_2)
356 staparam += M_PI *2;
357 if (endparam < M_PI_2)
358 endparam += M_PI *2;
359 endparam -= M_PI_2;
360 staparam -= M_PI_2;
361 }
362 }
363 }
364
365 //parts are the number of vertex to split polyline, default 128
toPolyline(DRW_Polyline * pol,int parts)366 void DRW_Ellipse::toPolyline(DRW_Polyline *pol, int parts){
367 double radMajor, radMinor, cosRot, sinRot, incAngle, curAngle;
368 radMajor = sqrt(secPoint.x*secPoint.x + secPoint.y*secPoint.y);
369 radMinor = radMajor*ratio;
370 //calculate sin & cos of included angle
371 incAngle = atan2(secPoint.y, secPoint.x);
372 cosRot = cos(incAngle);
373 sinRot = sin(incAngle);
374 incAngle = M_PIx2 / parts;
375 curAngle = staparam;
376 int i = static_cast<int>(curAngle / incAngle);
377 do {
378 if (curAngle > endparam) {
379 curAngle = endparam;
380 i = parts+2;
381 }
382 double cosCurr = cos(curAngle);
383 double sinCurr = sin(curAngle);
384 double x = basePoint.x + (cosCurr*cosRot*radMajor) - (sinCurr*sinRot*radMinor);
385 double y = basePoint.y + (cosCurr*sinRot*radMajor) + (sinCurr*cosRot*radMinor);
386 pol->addVertex( DRW_Vertex(x, y, 0.0, 0.0));
387 curAngle = (++i)*incAngle;
388 } while (i<parts);
389 if ( fabs(endparam - staparam - M_PIx2) < 1.0e-10){
390 pol->flags = 1;
391 }
392 pol->layer = this->layer;
393 pol->lineType = this->lineType;
394 pol->color = this->color;
395 pol->lWeight = this->lWeight;
396 pol->extPoint = this->extPoint;
397 }
398
applyExtrusion()399 void DRW_Trace::applyExtrusion(){
400 if (haveExtrusion) {
401 calculateAxis(extPoint);
402 extrudePoint(extPoint, &basePoint);
403 extrudePoint(extPoint, &secPoint);
404 extrudePoint(extPoint, &thirdPoint);
405 extrudePoint(extPoint, &fourPoint);
406 }
407 }
408
parseCode(int code,dxfReader * reader)409 void DRW_Trace::parseCode(int code, dxfReader *reader){
410 switch (code) {
411 case 12:
412 thirdPoint.x = reader->getDouble();
413 break;
414 case 22:
415 thirdPoint.y = reader->getDouble();
416 break;
417 case 32:
418 thirdPoint.z = reader->getDouble();
419 break;
420 case 13:
421 fourPoint.x = reader->getDouble();
422 break;
423 case 23:
424 fourPoint.y = reader->getDouble();
425 break;
426 case 33:
427 fourPoint.z = reader->getDouble();
428 break;
429 default:
430 DRW_Line::parseCode(code, reader);
431 break;
432 }
433 }
434
parseCode(int code,dxfReader * reader)435 void DRW_Solid::parseCode(int code, dxfReader *reader){
436 DRW_Trace::parseCode(code, reader);
437 }
438
parseCode(int code,dxfReader * reader)439 void DRW_3Dface::parseCode(int code, dxfReader *reader){
440 switch (code) {
441 case 70:
442 invisibleflag = reader->getInt32();
443 break;
444 default:
445 DRW_Trace::parseCode(code, reader);
446 break;
447 }
448 }
449
parseCode(int code,dxfReader * reader)450 void DRW_Block::parseCode(int code, dxfReader *reader){
451 switch (code) {
452 case 2:
453 name = reader->getUtf8String();
454 break;
455 case 70:
456 flags = reader->getInt32();
457 break;
458 default:
459 DRW_Point::parseCode(code, reader);
460 break;
461 }
462 }
463
parseCode(int code,dxfReader * reader)464 void DRW_Insert::parseCode(int code, dxfReader *reader){
465 switch (code) {
466 case 2:
467 name = reader->getUtf8String();
468 break;
469 case 41:
470 xscale = reader->getDouble();
471 break;
472 case 42:
473 yscale = reader->getDouble();
474 break;
475 case 43:
476 zscale = reader->getDouble();
477 break;
478 case 50:
479 angle = reader->getDouble();
480 angle = angle/ARAD; //convert to radian
481 break;
482 case 70:
483 colcount = reader->getInt32();
484 break;
485 case 71:
486 rowcount = reader->getInt32();
487 break;
488 case 44:
489 colspace = reader->getDouble();
490 break;
491 case 45:
492 rowspace = reader->getDouble();
493 break;
494 default:
495 DRW_Point::parseCode(code, reader);
496 break;
497 }
498 }
499
applyExtrusion()500 void DRW_LWPolyline::applyExtrusion(){
501 if (haveExtrusion) {
502 calculateAxis(extPoint);
503 for (unsigned int i=0; i<vertlist.size(); i++) {
504 DRW_Vertex2D *vert = vertlist.at(i);
505 DRW_Coord v(vert->x, vert->y, elevation);
506 extrudePoint(extPoint, &v);
507 vert->x = v.x;
508 vert->y = v.y;
509 }
510 }
511 }
512
parseCode(int code,dxfReader * reader)513 void DRW_LWPolyline::parseCode(int code, dxfReader *reader){
514 switch (code) {
515 case 10: {
516 vertex = new DRW_Vertex2D();
517 vertlist.push_back(vertex);
518 vertex->x = reader->getDouble();
519 break; }
520 case 20:
521 if(vertex != NULL)
522 vertex->y = reader->getDouble();
523 break;
524 case 40:
525 if(vertex != NULL)
526 vertex->stawidth = reader->getDouble();
527 break;
528 case 41:
529 if(vertex != NULL)
530 vertex->endwidth = reader->getDouble();
531 break;
532 case 42:
533 if(vertex != NULL)
534 vertex->bulge = reader->getDouble();
535 break;
536 case 38:
537 elevation = reader->getDouble();
538 break;
539 case 39:
540 thickness = reader->getDouble();
541 break;
542 case 43:
543 width = reader->getDouble();
544 break;
545 case 70:
546 flags = reader->getInt32();
547 break;
548 case 90:
549 vertexnum = reader->getInt32();
550 vertlist.reserve(static_cast<size_t>(vertexnum));
551 break;
552 case 210:
553 haveExtrusion = true;
554 extPoint.x = reader->getDouble();
555 break;
556 case 220:
557 extPoint.y = reader->getDouble();
558 break;
559 case 230:
560 extPoint.z = reader->getDouble();
561 break;
562 default:
563 DRW_Entity::parseCode(code, reader);
564 break;
565 }
566 }
567
parseCode(int code,dxfReader * reader)568 void DRW_Text::parseCode(int code, dxfReader *reader){
569 switch (code) {
570 case 40:
571 height = reader->getDouble();
572 break;
573 case 41:
574 widthscale = reader->getDouble();
575 break;
576 case 50:
577 angle = reader->getDouble();
578 break;
579 case 51:
580 oblique = reader->getDouble();
581 break;
582 case 71:
583 textgen = reader->getInt32();
584 break;
585 case 72:
586 alignH = static_cast<HAlign>(reader->getInt32());
587 break;
588 case 73:
589 alignV = static_cast<VAlign>(reader->getInt32());
590 break;
591 case 1:
592 text = reader->getUtf8String();
593 break;
594 case 7:
595 style = reader->getUtf8String();
596 break;
597 default:
598 DRW_Line::parseCode(code, reader);
599 break;
600 }
601 }
602
parseCode(int code,dxfReader * reader)603 void DRW_MText::parseCode(int code, dxfReader *reader){
604 switch (code) {
605 case 1:
606 text += reader->getString();
607 text = reader->toUtf8String(text);
608 break;
609 case 11:
610 haveXAxis = true;
611 DRW_Text::parseCode(code, reader);
612 break;
613 case 3:
614 text += reader->getString();
615 break;
616 case 44:
617 interlin = reader->getDouble();
618 break;
619 case 71: {
620 // Attachment point
621 Attach a = static_cast<Attach>(reader->getInt32());
622
623 QT_WARNING_PUSH
624 QT_WARNING_DISABLE_GCC("-Wswitch-default")
625
626 switch(a) {
627 case TopLeft:
628 alignV = VTop;
629 alignH = HLeft;
630 break;
631 case TopCenter:
632 alignV = VTop;
633 alignH = HCenter;
634 break;
635 case TopRight:
636 alignV = VTop;
637 alignH = HRight;
638 break;
639 case MiddleLeft:
640 alignV = VMiddle;
641 alignH = HLeft;
642 break;
643 case MiddleCenter:
644 alignV = VMiddle;
645 alignH = HCenter;
646 break;
647 case MiddleRight:
648 alignV = VMiddle;
649 alignH = HRight;
650 break;
651 case BottomLeft:
652 alignV = VBottom;
653 alignH = HLeft;
654 break;
655 case BottomCenter:
656 alignV = VBottom;
657 alignH = HCenter;
658 break;
659 case BottomRight:
660 alignV = VBottom;
661 alignH = HRight;
662 break;
663 }
664
665 QT_WARNING_POP
666 } break;
667 case 72:
668 // To prevent redirection to DRW_Text::parseCode.
669 // This code meaning is different for MTEXT.
670 // Actually: Drawing direction
671 break;
672 case 73:
673 // To prevent redirection to DRW_Text::parseCode.
674 // This code meaning is different for MTEXT.
675 // Actually: Mtext line spacing style
676 break;
677 default:
678 DRW_Text::parseCode(code, reader);
679 break;
680 }
681 }
682
updateAngle()683 void DRW_MText::updateAngle(){
684 if (haveXAxis) {
685 angle = atan2(secPoint.y, secPoint.x)*180/M_PI;
686 }
687 }
688
parseCode(int code,dxfReader * reader)689 void DRW_Polyline::parseCode(int code, dxfReader *reader){
690 switch (code) {
691 case 70:
692 flags = reader->getInt32();
693 break;
694 case 40:
695 defstawidth = reader->getDouble();
696 break;
697 case 41:
698 defendwidth = reader->getDouble();
699 break;
700 case 71:
701 vertexcount = reader->getInt32();
702 break;
703 case 72:
704 facecount = reader->getInt32();
705 break;
706 case 73:
707 smoothM = reader->getInt32();
708 break;
709 case 74:
710 smoothN = reader->getInt32();
711 break;
712 case 75:
713 curvetype = reader->getInt32();
714 break;
715 default:
716 DRW_Point::parseCode(code, reader);
717 break;
718 }
719 }
720
parseCode(int code,dxfReader * reader)721 void DRW_Vertex::parseCode(int code, dxfReader *reader){
722 switch (code) {
723 case 70:
724 flags = reader->getInt32();
725 break;
726 case 40:
727 stawidth = reader->getDouble();
728 break;
729 case 41:
730 endwidth = reader->getDouble();
731 break;
732 case 42:
733 bulge = reader->getDouble();
734 break;
735 case 50:
736 tgdir = reader->getDouble();
737 break;
738 case 71:
739 vindex1 = reader->getInt32();
740 break;
741 case 72:
742 vindex2 = reader->getInt32();
743 break;
744 case 73:
745 vindex3 = reader->getInt32();
746 break;
747 case 74:
748 vindex4 = reader->getInt32();
749 break;
750 case 91:
751 identifier = reader->getInt32();
752 break;
753 default:
754 DRW_Point::parseCode(code, reader);
755 break;
756 }
757 }
758
parseCode(int code,dxfReader * reader)759 void DRW_Hatch::parseCode(int code, dxfReader *reader){
760 switch (code) {
761 case 2:
762 name = reader->getUtf8String();
763 break;
764 case 70:
765 solid = reader->getInt32();
766 break;
767 case 71:
768 associative = reader->getInt32();
769 break;
770 case 72: /*edge type*/
771 if (ispol){ //if is polyline is a as_bulge flag
772 break;
773 } else if (reader->getInt32() == 1){ //line
774 addLine();
775 } else if (reader->getInt32() == 2){ //arc
776 addArc();
777 } else if (reader->getInt32() == 3){ //elliptic arc
778 addEllipse();
779 } else if (reader->getInt32() == 4){ //spline
780 addSpline();
781 }
782 break;
783 case 10:
784 if (pt) pt->basePoint.x = reader->getDouble();
785 else if (pline) {
786 plvert = pline->addVertex();
787 plvert->x = reader->getDouble();
788 }
789 break;
790 case 20:
791 if (pt) pt->basePoint.y = reader->getDouble();
792 else if (plvert) plvert ->y = reader->getDouble();
793 break;
794 case 11:
795 if (line) line->secPoint.x = reader->getDouble();
796 else if (ellipse) ellipse->secPoint.x = reader->getDouble();
797 break;
798 case 21:
799 if (line) line->secPoint.y = reader->getDouble();
800 else if (ellipse) ellipse->secPoint.y = reader->getDouble();
801 break;
802 case 40:
803 if (arc) arc->radious = reader->getDouble();
804 else if (ellipse) ellipse->ratio = reader->getDouble();
805 break;
806 case 41:
807 scale = reader->getDouble();
808 break;
809 case 42:
810 if (plvert) plvert ->bulge = reader->getDouble();
811 break;
812 case 50:
813 if (arc) arc->staangle = reader->getDouble()/ARAD;
814 else if (ellipse) ellipse->staparam = reader->getDouble()/ARAD;
815 break;
816 case 51:
817 if (arc) arc->endangle = reader->getDouble()/ARAD;
818 else if (ellipse) ellipse->endparam = reader->getDouble()/ARAD;
819 break;
820 case 52:
821 angle = reader->getDouble();
822 break;
823 case 73:
824 if (arc) arc->isccw = reader->getInt32();
825 else if (pline) pline->flags = reader->getInt32();
826 break;
827 case 75:
828 hstyle = reader->getInt32();
829 break;
830 case 76:
831 hpattern = reader->getInt32();
832 break;
833 case 77:
834 doubleflag = reader->getInt32();
835 break;
836 case 78:
837 deflines = reader->getInt32();
838 break;
839 case 91:
840 loopsnum = reader->getInt32();
841 looplist.reserve(static_cast<size_t>(loopsnum));
842 break;
843 case 92:
844 loop = new DRW_HatchLoop(reader->getInt32());
845 looplist.push_back(loop);
846 if (reader->getInt32() & 2) {
847 ispol = true;
848 clearEntities();
849 pline = new DRW_LWPolyline;
850 loop->objlist.push_back(pline);
851 } else ispol = false;
852 break;
853 case 93:
854 if (pline) pline->vertexnum = reader->getInt32();
855 else loop->numedges = reader->getInt32();//aqui reserve
856 break;
857 case 98: //seed points ??
858 clearEntities();
859 break;
860 default:
861 DRW_Point::parseCode(code, reader);
862 break;
863 }
864 }
865
parseCode(int code,dxfReader * reader)866 void DRW_Spline::parseCode(int code, dxfReader *reader){
867 switch (code) {
868 case 210:
869 normalVec.x = reader->getDouble();
870 break;
871 case 220:
872 normalVec.y = reader->getDouble();
873 break;
874 case 230:
875 normalVec.z = reader->getDouble();
876 break;
877 case 12:
878 tgStart.x = reader->getDouble();
879 break;
880 case 22:
881 tgStart.y = reader->getDouble();
882 break;
883 case 32:
884 tgStart.z = reader->getDouble();
885 break;
886 case 13:
887 tgEnd.x = reader->getDouble();
888 break;
889 case 23:
890 tgEnd.y = reader->getDouble();
891 break;
892 case 33:
893 tgEnd.z = reader->getDouble();
894 break;
895 case 70:
896 flags = reader->getInt32();
897 break;
898 case 71:
899 degree = reader->getInt32();
900 break;
901 case 72:
902 nknots = reader->getInt32();
903 break;
904 case 73:
905 ncontrol = reader->getInt32();
906 break;
907 case 74:
908 nfit = reader->getInt32();
909 break;
910 case 42:
911 tolknot = reader->getDouble();
912 break;
913 case 43:
914 tolcontrol = reader->getDouble();
915 break;
916 case 44:
917 tolfit = reader->getDouble();
918 break;
919 case 10: {
920 controlpoint = new DRW_Coord();
921 controllist.push_back(controlpoint);
922 controlpoint->x = reader->getDouble();
923 break; }
924 case 20:
925 if(controlpoint != NULL)
926 controlpoint->y = reader->getDouble();
927 break;
928 case 30:
929 if(controlpoint != NULL)
930 controlpoint->z = reader->getDouble();
931 break;
932 case 11: {
933 fitpoint = new DRW_Coord();
934 fitlist.push_back(fitpoint);
935 fitpoint->x = reader->getDouble();
936 break; }
937 case 21:
938 if(fitpoint != NULL)
939 fitpoint->y = reader->getDouble();
940 break;
941 case 31:
942 if(fitpoint != NULL)
943 fitpoint->z = reader->getDouble();
944 break;
945 case 40:
946 knotslist.push_back(reader->getDouble());
947 break;
948 case 41:
949 weightlist.push_back(reader->getDouble());
950 break;
951 default:
952 DRW_Entity::parseCode(code, reader);
953 break;
954 }
955 }
956
parseCode(int code,dxfReader * reader)957 void DRW_Image::parseCode(int code, dxfReader *reader){
958 switch (code) {
959 case 12:
960 vVector.x = reader->getDouble();
961 break;
962 case 22:
963 vVector.y = reader->getDouble();
964 break;
965 case 32:
966 vVector.z = reader->getDouble();
967 break;
968 case 13:
969 sizeu = reader->getDouble();
970 break;
971 case 23:
972 sizev = reader->getDouble();
973 break;
974 case 340:
975 ref = static_cast<duint32>(reader->getHandleString());
976 break;
977 case 280:
978 clip = reader->getInt32();
979 break;
980 case 281:
981 brightness = reader->getInt32();
982 break;
983 case 282:
984 contrast = reader->getInt32();
985 break;
986 case 283:
987 fade = reader->getInt32();
988 break;
989 default:
990 DRW_Line::parseCode(code, reader);
991 break;
992 }
993 }
994
parseCode(int code,dxfReader * reader)995 void DRW_Dimension::parseCode(int code, dxfReader *reader){
996 switch (code) {
997 case 1:
998 text = reader->getUtf8String();
999 break;
1000 case 2:
1001 name = reader->getString();
1002 break;
1003 case 3:
1004 style = reader->getUtf8String();
1005 break;
1006 case 70:
1007 type = reader->getInt32();
1008 break;
1009 case 71:
1010 align = reader->getInt32();
1011 break;
1012 case 72:
1013 linesty = reader->getInt32();
1014 break;
1015 case 10:
1016 defPoint.x = reader->getDouble();
1017 break;
1018 case 20:
1019 defPoint.y = reader->getDouble();
1020 break;
1021 case 30:
1022 defPoint.z = reader->getDouble();
1023 break;
1024 case 11:
1025 textPoint.x = reader->getDouble();
1026 break;
1027 case 21:
1028 textPoint.y = reader->getDouble();
1029 break;
1030 case 31:
1031 textPoint.z = reader->getDouble();
1032 break;
1033 case 12:
1034 clonePoint.x = reader->getDouble();
1035 break;
1036 case 22:
1037 clonePoint.y = reader->getDouble();
1038 break;
1039 case 32:
1040 clonePoint.z = reader->getDouble();
1041 break;
1042 case 13:
1043 def1.x = reader->getDouble();
1044 break;
1045 case 23:
1046 def1.y = reader->getDouble();
1047 break;
1048 case 33:
1049 def1.z = reader->getDouble();
1050 break;
1051 case 14:
1052 def2.x = reader->getDouble();
1053 break;
1054 case 24:
1055 def2.y = reader->getDouble();
1056 break;
1057 case 34:
1058 def2.z = reader->getDouble();
1059 break;
1060 case 15:
1061 circlePoint.x = reader->getDouble();
1062 break;
1063 case 25:
1064 circlePoint.y = reader->getDouble();
1065 break;
1066 case 35:
1067 circlePoint.z = reader->getDouble();
1068 break;
1069 case 16:
1070 arcPoint.x = reader->getDouble();
1071 break;
1072 case 26:
1073 arcPoint.y = reader->getDouble();
1074 break;
1075 case 36:
1076 arcPoint.z = reader->getDouble();
1077 break;
1078 case 41:
1079 linefactor = reader->getDouble();
1080 break;
1081 case 42:
1082 actual = reader->getDouble();
1083 hasActual = not qFuzzyIsNull(actual);
1084 break;
1085 case 53:
1086 rot = reader->getDouble();
1087 break;
1088 case 50:
1089 angle = reader->getDouble();
1090 break;
1091 case 52:
1092 oblique = reader->getDouble();
1093 break;
1094 case 40:
1095 length = reader->getDouble();
1096 break;
1097 case 51:
1098 hdir = reader->getDouble();
1099 break;
1100 default:
1101 DRW_Entity::parseCode(code, reader);
1102 break;
1103 }
1104 }
1105
parseCode(int code,dxfReader * reader)1106 void DRW_Leader::parseCode(int code, dxfReader *reader){
1107 switch (code) {
1108 case 3:
1109 style = reader->getUtf8String();
1110 break;
1111 case 71:
1112 arrow = reader->getInt32();
1113 break;
1114 case 72:
1115 leadertype = reader->getInt32();
1116 break;
1117 case 73:
1118 flag = reader->getInt32();
1119 break;
1120 case 74:
1121 hookline = reader->getInt32();
1122 break;
1123 case 75:
1124 hookflag = reader->getInt32();
1125 break;
1126 case 76:
1127 vertnum = reader->getInt32();
1128 break;
1129 case 77:
1130 coloruse = reader->getInt32();
1131 break;
1132 case 40:
1133 textheight = reader->getDouble();
1134 break;
1135 case 41:
1136 textwidth = reader->getDouble();
1137 break;
1138 case 10: {
1139 vertexpoint = new DRW_Coord();
1140 vertexlist.push_back(vertexpoint);
1141 vertexpoint->x = reader->getDouble();
1142 break; }
1143 case 20:
1144 if(vertexpoint != NULL)
1145 vertexpoint->y = reader->getDouble();
1146 break;
1147 case 30:
1148 if(vertexpoint != NULL)
1149 vertexpoint->z = reader->getDouble();
1150 break;
1151 case 340:
1152 annotHandle = static_cast<duint32>(reader->getHandleString());
1153 break;
1154 case 210:
1155 extrusionPoint.x = reader->getDouble();
1156 break;
1157 case 220:
1158 extrusionPoint.y = reader->getDouble();
1159 break;
1160 case 230:
1161 extrusionPoint.z = reader->getDouble();
1162 break;
1163 case 211:
1164 horizdir.x = reader->getDouble();
1165 break;
1166 case 221:
1167 horizdir.y = reader->getDouble();
1168 break;
1169 case 231:
1170 horizdir.z = reader->getDouble();
1171 break;
1172 case 212:
1173 offsetblock.x = reader->getDouble();
1174 break;
1175 case 222:
1176 offsetblock.y = reader->getDouble();
1177 break;
1178 case 232:
1179 offsetblock.z = reader->getDouble();
1180 break;
1181 case 213:
1182 offsettext.x = reader->getDouble();
1183 break;
1184 case 223:
1185 offsettext.y = reader->getDouble();
1186 break;
1187 case 233:
1188 offsettext.z = reader->getDouble();
1189 break;
1190 default:
1191 DRW_Entity::parseCode(code, reader);
1192 break;
1193 }
1194 }
1195
parseCode(int code,dxfReader * reader)1196 void DRW_Viewport::parseCode(int code, dxfReader *reader){
1197 switch (code) {
1198 case 40:
1199 pswidth = reader->getDouble();
1200 break;
1201 case 41:
1202 psheight = reader->getDouble();
1203 break;
1204 case 68:
1205 vpstatus = reader->getInt32();
1206 break;
1207 case 69:
1208 vpID = reader->getInt32();
1209 break;
1210 case 12: {
1211 centerPX = reader->getDouble();
1212 break; }
1213 case 22:
1214 centerPY = reader->getDouble();
1215 break;
1216 default:
1217 DRW_Point::parseCode(code, reader);
1218 break;
1219 }
1220 }
1221