root/OpenSceneGraph/trunk/src/osgPlugins/dxf/dxfEntity.cpp @ 13041

Revision 13041, 29.2 kB (checked in by robert, 14 months ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* dxfReader for OpenSceneGraph  Copyright (C) 2005 by GraphArchitecture ( grapharchitecture.com )
2 * Programmed by Paul de Repentigny <pdr@grapharchitecture.com>
3 *
4 * OpenSceneGraph is (C) 2004 Robert Osfield
5 *
6 * This library is provided as-is, without support of any kind.
7 *
8 * Read DXF docs or OSG docs for any related questions.
9 *
10 * You may contact the author if you have suggestions/corrections/enhancements.
11 */
12
13#include "dxfEntity.h"
14#include "dxfFile.h"
15#include "scene.h"
16#include "dxfBlock.h"
17#include "codeValue.h"
18
19#include <osg/io_utils> // just for debugging
20
21using namespace std;
22using namespace osg;
23
24// static
25std::map<std::string, ref_ptr<dxfBasicEntity> > dxfEntity::_registry;
26RegisterEntityProxy<dxf3DFace> g_dxf3DFace;
27RegisterEntityProxy<dxfCircle> g_dxfCircle;
28RegisterEntityProxy<dxfArc> g_dxfArc;
29RegisterEntityProxy<dxfPoint> g_dxfPoint;
30RegisterEntityProxy<dxfLine> g_dxfLine;
31RegisterEntityProxy<dxfVertex> g_dxfVertex;
32RegisterEntityProxy<dxfPolyline> g_dxfPolyline;
33RegisterEntityProxy<dxfLWPolyline> g_dxfLWPolyline;
34RegisterEntityProxy<dxfInsert> g_dxfInsert;
35RegisterEntityProxy<dxfText> g_dxfText;
36
37void
38dxfBasicEntity::assign(dxfFile* , codeValue& cv)
39{
40    switch (cv._groupCode) {
41        case 8:
42            _layer = cv._string;
43            break;
44        case 62:
45            _color = cv._short;
46            break;
47    }
48}
49
50void
51dxf3DFace::assign(dxfFile* dxf, codeValue& cv)
52{
53    double d = cv._double;
54    switch (cv._groupCode) {
55        case 10:
56        case 11:
57        case 12:
58        case 13:
59            _vertices[cv._groupCode - 10].x() = d;
60            break;
61        case 20:
62        case 21:
63        case 22:
64        case 23:
65            _vertices[cv._groupCode - 20].y() = d;
66            break;
67        case 30:
68        case 31:
69        case 32:
70        case 33:
71            _vertices[cv._groupCode - 30].z() = d;
72            break;
73
74        default:
75            dxfBasicEntity::assign(dxf, cv);
76            break;
77    }
78}
79
80void
81dxf3DFace::drawScene(scene* sc)
82{
83    std::vector<Vec3d> vlist;
84    short nfaces = 3;
85
86    // Hate to do that, but hey, that's written in the DXF specs:
87    if (_vertices[2] != _vertices[3]) nfaces = 4;
88
89    for (short i = nfaces-1; i >= 0; i--)
90        vlist.push_back(_vertices[i]);
91
92    if (nfaces == 3) {
93        // to do make sure we're % 3
94        sc->addTriangles(getLayer(), _color, vlist);
95    } else if (nfaces == 4) {
96        // to do make sure we're % 4
97        sc->addQuads(getLayer(), _color, vlist);
98    }
99}
100
101void
102dxfVertex::assign(dxfFile* dxf, codeValue& cv)
103{
104    double d = cv._double;
105    // 2005.12.13 pdr: learned today that negative indices mean something and were possible
106
107    int s = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
108    if ( s < 0 ) s = -s;
109    switch (cv._groupCode) {
110        case 10:
111            _vertex.x() = d;
112            break;
113        case 20:
114            _vertex.y() = d;
115            break;
116        case 30:
117            _vertex.z() = d;
118            break;
119        case 71:
120            _indice1 = s;
121            break;
122        case 72:
123            _indice2 = s;
124            break;
125        case 73:
126            _indice3 = s;
127            break;
128        case 74:
129            _indice4 = s;
130            break;
131
132        default:
133            dxfBasicEntity::assign(dxf, cv);
134            break;
135    }
136}
137
138void
139dxfCircle::assign(dxfFile* dxf, codeValue& cv)
140{
141    double d = cv._double;
142    //unsigned short s = cv._short;
143    switch (cv._groupCode) {
144        case 10:
145            _center.x() = d;
146            break;
147        case 20:
148            _center.y() = d;
149            break;
150        case 30:
151            _center.z() = d;
152            break;
153        case 40:
154            _radius = d;
155            break;
156        case 210:
157            _ocs.x() = d;
158            break;
159        case 220:
160            _ocs.y() = d;
161            break;
162        case 230:
163            _ocs.z() = d;
164            break;
165        default:
166            dxfBasicEntity::assign(dxf, cv);
167            break;
168    }
169}
170
171void
172dxfCircle::drawScene(scene* sc)
173{
174    Matrixd m;
175    getOCSMatrix(_ocs, m);
176    sc->ocs(m);
177    std::vector<Vec3d> vlist;
178
179    double theta=5.0; // we generate polyline from "spokes" at theta degrees at arc's center
180
181    if (_useAccuracy) {
182        // we generate points on a polyline where each point lies on the arc, thus the maximum error occurs at the midpoint of each line segment where it lies furthest inside the arc
183        // If we divide the segment in half and connect the bisection point to the arc's center, we have two rightangled triangles with
184        // one side=r-maxError, hypotenuse=r, and internal angle at center is half the angle we will step with:
185        double maxError=min(_maxError,_radius); // Avoid offending acos() in the edge case where allowable deviation is greater than radius.
186        double newtheta=acos( (_radius-maxError) / _radius);
187        newtheta=osg::RadiansToDegrees(newtheta)*2.0;
188
189        // Option to only use the new accuracy code when it would improve on the accuracy of the old method
190        if (_improveAccuracyOnly) {
191            theta=min(newtheta,theta);
192        } else {
193            theta=newtheta;
194        }
195    }
196    theta=osg::DegreesToRadians(theta);
197
198    // We create an anglestep<=theta so that the line's points are evenly distributed around the circle
199    unsigned int numsteps=static_cast<unsigned int>(floor(osg::PI*2/theta));
200    if (numsteps<3) numsteps=3; // Sanity check: minimal representation of a circle is a tri
201    double anglestep=osg::PI*2/numsteps;
202
203    double angle1 = 0.0;
204    Vec3d a = _center;
205    Vec3d b;
206    for(unsigned int r=0;r<=numsteps;r++) {
207        b = a + Vec3d(_radius * (double) sin(angle1), _radius * (double) cos(angle1), 0);
208        angle1 += anglestep;
209        vlist.push_back(b);
210    }
211
212    sc->addLineStrip(getLayer(), _color, vlist); // Should really add LineLoop implementation and save a vertex
213    sc->ocs_clear();
214}
215
216
217void
218dxfArc::assign(dxfFile* dxf, codeValue& cv)
219{
220    double d = cv._double;
221    //unsigned short s = cv._short;
222    switch (cv._groupCode) {
223        case 10:
224            _center.x() = d;
225            break;
226        case 20:
227            _center.y() = d;
228            break;
229        case 30:
230            _center.z() = d;
231            break;
232        case 40:
233            _radius = d;
234            break;
235        case 50:
236            _startAngle = d;
237            break;
238        case 51:
239            _endAngle = d;
240            break;
241        case 210:
242            _ocs.x() = d;
243            break;
244        case 220:
245            _ocs.y() = d;
246            break;
247        case 230:
248            _ocs.z() = d;
249            break;
250        default:
251            dxfBasicEntity::assign(dxf, cv);
252            break;
253    }
254}
255
256void
257dxfArc::drawScene(scene* sc)
258{
259    Matrixd m;
260    getOCSMatrix(_ocs, m);
261    sc->ocs(m);
262    std::vector<Vec3d> vlist;
263    double end;
264    double start;
265    if (_startAngle > _endAngle) {
266        start = _startAngle;
267        end = _endAngle + 360;
268    } else {
269        start = _startAngle;
270        end = _endAngle;
271    }
272
273    double theta=5.0; // we generate polyline from "spokes" at theta degrees at arc's center
274
275    if (_useAccuracy) {
276        // we generate points on a polyline where each point lies on the arc, thus the maximum error occurs at the midpoint of each line segment where it lies furthest inside the arc
277        // If we divide the segment in half and connect the bisection point to the arc's center, we have two rightangled triangles with
278        // one side=r-maxError, hypotenuse=r, and internal angle at center is half the angle we will step with:
279        double maxError=min(_maxError,_radius); // Avoid offending acos() in the edge case where allowable deviation is greater than radius.
280        double newtheta=acos( (_radius-maxError) / _radius);
281        newtheta=osg::RadiansToDegrees(newtheta)*2.0;
282        //cout<<"r="<<_radius<<" _me="<<_maxError<<" (_radius-_maxError)="<<(_radius-_maxError)<<" newtheta="<<newtheta<<endl;
283        // Option to only use the new accuracy code when it would improve on the accuracy of the old method
284        if (_improveAccuracyOnly) {
285            theta=min(newtheta,theta);
286        } else {
287            theta=newtheta;
288        }
289    }
290
291    double angle_step = DegreesToRadians(end - start);
292    int numsteps = (int)((end - start)/theta);
293    //cout<<"arc theta="<<osg::RadiansToDegrees(theta)<<" end="<<end<<" start="<<start<<" numsteps="<<numsteps<<" e-s/theta="<<((end-start)/theta)<<" end-start="<<(end-start)<<endl;
294    if (numsteps * theta < (end - start)) numsteps++;
295    numsteps=max(numsteps,2); // Whatever else, minimum representation of an arc is a straightline
296    angle_step /=  (double) numsteps;
297    end = DegreesToRadians((-_startAngle)+90.0);
298    start = DegreesToRadians((-_endAngle)+90.0);
299    double angle1 = start;
300
301    Vec3d a = _center;
302    Vec3d b;
303
304    for (int r = 0; r <= numsteps; r++)
305    {
306        b = a + Vec3d(_radius * (double) sin(angle1), _radius * (double) cos(angle1), 0);
307        angle1 += angle_step;
308        vlist.push_back(b);
309    }
310
311
312    sc->addLineStrip(getLayer(), _color, vlist);
313    sc->ocs_clear();
314}
315
316void
317dxfLine::assign(dxfFile* dxf, codeValue& cv)
318{
319    double d = cv._double;
320    //unsigned short s = cv._short;
321    switch (cv._groupCode) {
322        case 10:
323            _a.x() = d;
324            break;
325        case 20:
326            _a.y() = d;
327            break;
328        case 30:
329            _a.z() = d;
330            break;
331        case 11:
332            _b.x() = d;
333            break;
334        case 21:
335            _b.y() = d;
336            break;
337        case 31:
338            _b.z() = d;
339            break;
340        case 210:
341            _ocs.x() = d;
342            break;
343        case 220:
344            _ocs.y() = d;
345            break;
346        case 230:
347            _ocs.z() = d;
348            break;
349        default:
350            dxfBasicEntity::assign(dxf, cv);
351            break;
352    }
353}
354
355void
356dxfLine::drawScene(scene* sc)
357{
358    Matrixd m;
359    getOCSMatrix(_ocs, m);
360    // don't know why this doesn't work
361//    sc->ocs(m);
362    sc->addLine(getLayer(), _color, _b, _a);
363//    static long lcount = 0;
364//    std::cout << ++lcount << " ";
365//    sc->ocs_clear();
366}
367void
368dxfPoint::assign(dxfFile* dxf, codeValue& cv)
369{
370    double d = cv._double;
371    //unsigned short s = cv._short;
372    switch (cv._groupCode) {
373        case 10:
374            _a.x() = d;
375            break;
376        case 20:
377            _a.y() = d;
378            break;
379        case 30:
380            _a.z() = d;
381            break;
382        default:
383            dxfBasicEntity::assign(dxf, cv);
384            break;
385    }
386}
387
388void
389dxfPoint::drawScene(scene* sc)
390{
391    Matrixd m;
392    getOCSMatrix(_ocs, m);
393    sc->addPoint(getLayer(), _color,_a);
394}
395
396void
397dxfPolyline::assign(dxfFile* dxf, codeValue& cv)
398{
399    string s = cv._string;
400    if (cv._groupCode == 0) {
401        if (s == "VERTEX") {
402            _currentVertex = new dxfVertex;
403            _vertices.push_back(_currentVertex);
404        }
405    } else if (_currentVertex) {
406        _currentVertex->assign(dxf, cv);
407
408        if ((_flag & 64 /*i.e. polymesh*/) &&
409            (cv._groupCode == 70 /*i.e. vertex flag*/) &&
410            (cv._int & 128 /*i.e. vertex is actually a face*/))
411            _indices.push_back(_currentVertex); // Add the index only if _currentvertex is actually an index
412    } else {
413        double d = cv._double;
414        switch (cv._groupCode) {
415            case 10:
416                // dummy
417                break;
418            case 20:
419                // dummy
420                break;
421            case 30:
422                _elevation = d; // what is elevation?
423                break;
424            case 70:
425                _flag = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
426                break;
427            case 71:
428                // Meaningful only when _surfacetype == 6, don' trust it for polymeshes.
429                // From the docs :
430                // "The 71 group specifies the number of vertices in the mesh, and the 72 group
431                // specifies the number of faces. Although these counts are correct for all meshes
432                // created with the PFACE command, applications are not required to place correct
433                // values in these fields.)"
434                // Amusing isn't it ?
435                _mcount = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
436                break;
437            case 72:
438                // Meaningful only when _surfacetype == 6, don' trust it for polymeshes.
439                // From the docs :
440                // "The 71 group specifies the number of vertices in the mesh, and the 72 group
441                // specifies the number of faces. Although these counts are correct for all meshes
442                // created with the PFACE command, applications are not required to place correct
443                // values in these fields.)"
444                // Amusing isn't it ?
445                _ncount = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
446                break;
447            case 73:
448                _mdensity = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
449                break;
450            case 74:
451                _ndensity = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
452                break;
453            case 75:
454                _surfacetype = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
455                break;
456            case 210:
457                _ocs.x() = d;
458                break;
459            case 220:
460                _ocs.y() = d;
461                break;
462            case 230:
463                _ocs.z() = d;
464                break;
465            default:
466                dxfBasicEntity::assign(dxf, cv);
467                break;
468        }
469    }
470}
471
472
473void
474dxfPolyline::drawScene(scene* sc)
475{
476    Matrixd m;
477    getOCSMatrix(_ocs, m);
478    sc->ocs(m);
479    std::vector<Vec3d> vlist;
480    std::vector<Vec3d> qlist;
481    Vec3d a, b, c, d;
482    bool invert_order = false;
483    if (_flag & 16) {
484        std::vector<Vec3d> nlist;
485        Vec3d nr;
486        bool nset = false;
487        //dxfVertex* v = NULL;
488        unsigned int ncount;
489        unsigned int mcount;
490        if (_surfacetype == 6) {
491            // I dont have examples of type 5 and 8, but they may be the same as 6
492            mcount = _mdensity;
493            ncount = _ndensity;
494        } else {
495            mcount = _mcount;
496            ncount = _ncount;
497        }
498        for (unsigned int n = 0; n < ncount-1; n++) {
499            for (unsigned int m = 1; m < mcount; m++) {
500                // 0
501                a = _vertices[(m-1)*ncount+n].get()->getVertex();
502                // 1
503                b = _vertices[m*ncount+n].get()->getVertex();
504                // 3
505                c = _vertices[(m)*ncount+n+1].get()->getVertex();
506                // 2
507                d = _vertices[(m-1)*ncount+n+1].get()->getVertex();
508                if (a == b ) {
509                    vlist.push_back(a);
510                    vlist.push_back(c);
511                    vlist.push_back(d);
512                    b = c;
513                    c = d;
514                } else if (c == d) {
515                    vlist.push_back(a);
516                    vlist.push_back(b);
517                    vlist.push_back(c);
518                } else {
519                    qlist.push_back(a);
520                    qlist.push_back(b);
521                    qlist.push_back(c);
522                    qlist.push_back(d);
523                }
524                if (!nset) {
525                    nset = true;
526                    nr = (b - a) ^ (c - a);
527                    nr.normalize();
528                }
529                nlist.push_back(a);
530            }
531        }
532        if (_flag & 1) {
533            for (unsigned int n = 0; n < ncount-1; n++) {
534                // 0
535                a = _vertices[(mcount-1)*ncount+n].get()->getVertex();
536                // 1
537                b = _vertices[0*ncount+n].get()->getVertex();
538                // 3
539                c = _vertices[(0)*ncount+n+1].get()->getVertex();
540                // 2
541                d = _vertices[(mcount-1)*ncount+n+1].get()->getVertex();
542                if (a == b ) {
543                    vlist.push_back(a);
544                    vlist.push_back(c);
545                    vlist.push_back(d);
546                    b = c;
547                    c = d;
548                } else if (c == d) {
549                    vlist.push_back(a);
550                    vlist.push_back(b);
551                    vlist.push_back(c);
552                } else {
553                    qlist.push_back(a);
554                    qlist.push_back(b);
555                    qlist.push_back(c);
556                    qlist.push_back(d);
557                }
558                nlist.push_back(a);
559            }
560        }
561        if (_flag & 32) {
562            for (unsigned int m = 1; m < mcount; m++) {
563                // 0
564                a = _vertices[(m-1)*ncount+(ncount-1)].get()->getVertex();
565                // 1
566                b = _vertices[m*ncount+(ncount-1)].get()->getVertex();
567                // 3
568                c = _vertices[(m)*ncount].get()->getVertex();
569                // 2
570                d = _vertices[(m-1)*ncount].get()->getVertex();
571                if (a == b ) {
572                    vlist.push_back(a);
573                    vlist.push_back(c);
574                    vlist.push_back(d);
575                    b = c;
576                    c = d;
577                } else if (c == d) {
578                    vlist.push_back(a);
579                    vlist.push_back(b);
580                    vlist.push_back(c);
581                } else {
582                    qlist.push_back(a);
583                    qlist.push_back(b);
584                    qlist.push_back(c);
585                    qlist.push_back(d);
586                }
587                nlist.push_back(a);
588            }
589        }
590
591/*
592        // a naive attempt to determine vertex ordering
593        VList::iterator itr = nlist.begin();
594        Vec3d lastn = (*itr++);
595        double bad_c = 0;
596        double good_c = 0;
597        long bad=0,good=0;
598        for (; itr != nlist.end(); ++itr) {
599            if ((*itr)== lastn) continue;
600            Vec3d diff = ((*itr)-lastn);
601            diff.normalize();
602            float dot = diff * nr;
603            if (dot > 0.0) {
604                bad_c += dot;
605                ++bad;
606            } else {
607                ++good;
608                good_c += dot;
609            }
610        }
611        if (bad > good) {
612            invert_order = true;
613        }
614*/
615
616        if (qlist.size())
617            sc->addQuads(getLayer(), _color, qlist, invert_order);
618        if (vlist.size())
619            sc->addTriangles(getLayer(), _color, vlist, invert_order);
620
621    } else if (_flag & 64) {
622        unsigned short _facetype = 3;
623
624        for (unsigned int i = 0; i < _indices.size(); i++) {
625            dxfVertex* vindice = _indices[i].get();
626            if (!vindice) continue;
627            if (vindice->getIndice4()) {
628                _facetype = 4;
629                d = _vertices[vindice->getIndice4()-1].get()->getVertex();
630            } else {
631                _facetype = 3;
632            }
633            if (vindice->getIndice3()) {
634                c = _vertices[vindice->getIndice3()-1].get()->getVertex();
635            } else {
636                c = vindice->getVertex(); // Vertex not indexed. Use as is
637            }
638            if (vindice->getIndice2()) {
639                b = _vertices[vindice->getIndice2()-1].get()->getVertex();
640            } else {
641                b = vindice->getVertex(); // Vertex not indexed. Use as is
642            }
643            if (vindice->getIndice1()) {
644                a = _vertices[vindice->getIndice1()-1].get()->getVertex();
645            } else {
646                a = vindice->getVertex(); // Vertex not indexed. Use as is
647            }
648            if (_facetype == 4) {
649                qlist.push_back(d);
650                qlist.push_back(c);
651                qlist.push_back(b);
652                qlist.push_back(a);
653            } else {
654                // 2005.12.13 pdr: vlist! not qlist!
655                vlist.push_back(c);
656                vlist.push_back(b);
657                vlist.push_back(a);
658            }
659        }
660        if (vlist.size())
661            sc->addTriangles(getLayer(), _color, vlist);
662        if (qlist.size())
663            sc->addQuads(getLayer(), _color, qlist);
664        // is there a flag 1 or 32 for 64?
665    } else {
666        // simple polyline?
667        for (int i = _vertices.size()-1; i >= 0; i--)
668            vlist.push_back(_vertices[i]->getVertex());
669        if (_flag & 1) {
670//            std::cout << "line loop " << _vertices.size() << std::endl;
671            sc->addLineLoop(getLayer(), _color, vlist);
672        } else {
673//            std::cout << "line strip " << _vertices.size() << std::endl;
674            sc->addLineStrip(getLayer(), _color, vlist);
675        }
676
677    }
678    sc->ocs_clear();
679}
680
681void
682dxfLWPolyline::assign(dxfFile* dxf, codeValue& cv)
683{
684    string s = cv._string;
685
686    double d = cv._double;
687    switch (cv._groupCode) {
688        case 10:
689            _lastv.x() = d;
690            // x
691            break;
692        case 20:
693            _lastv.y() = d;
694            _lastv.z() = _elevation;
695            _vertices.push_back ( _lastv );
696            // y -> on shoot
697            break;
698        case 38:
699            _elevation = d; // what is elevation?
700            break;
701        case 70:
702            _flag = cv._int; // 2005.12.13 pdr: group codes [70,78] now signed int.
703            break;
704        case 90:
705            _vcount = cv._short;
706            break;
707        case 210:
708            _ocs.x() = d;
709            break;
710        case 220:
711            _ocs.y() = d;
712            break;
713        case 230:
714            _ocs.z() = d;
715            break;
716        default:
717            dxfBasicEntity::assign(dxf, cv);
718            break;
719    }
720}
721
722
723void
724dxfLWPolyline::drawScene(scene* sc)
725{
726//    if (getLayer() != "UDF2" && getLayer() != "ENGINES") return;
727//    if (!(_flag & 16)) return;
728    Matrixd m;
729    getOCSMatrix(_ocs, m);
730    sc->ocs(m);
731    if (_flag & 1) {
732//        std::cout << "lwpolyline line loop " << _vertices.size() << std::endl;
733        sc->addLineLoop(getLayer(), _color, _vertices);
734    } else {
735//        std::cout << "lwpolyline line strip " << _vertices.size() << std::endl;
736        sc->addLineStrip(getLayer(), _color, _vertices);
737    }
738    sc->ocs_clear();
739}
740
741void
742dxfInsert::assign(dxfFile* dxf, codeValue& cv)
743{
744    string s = cv._string;
745    if (_done || (cv._groupCode == 0 && s != "INSERT")) {
746        _done = true;
747        return;
748    }
749    if (cv._groupCode == 2 && !_block) {
750        _blockName = s;
751        _block = dxf->findBlock(s);
752    } else {
753        double d = cv._double;
754        switch (cv._groupCode) {
755            case 10:
756                _point.x() = d;
757                break;
758            case 20:
759                _point.y() = d;
760                break;
761            case 30:
762                _point.z() = d;
763                break;
764            case 41:
765                _scale.x() = d;
766                break;
767            case 42:
768                _scale.y() = d;
769                break;
770            case 43:
771                _scale.z() = d;
772                break;
773            case 50:
774                _rotation = d;
775                break;
776            case 210:
777                _ocs.x() = d;
778                break;
779            case 220:
780                _ocs.y() = d;
781                break;
782            case 230:
783                _ocs.z() = d;
784                break;
785            default:
786                dxfBasicEntity::assign(dxf, cv);
787                break;
788        }
789    }
790}
791
792/// hum. read the doc, then come back here. then try to figure.
793void
794dxfInsert::drawScene(scene* sc)
795{
796    // INSERTs can be nested. So pull the current matrix
797    // and push it back after we fill our context
798    // This is a snapshot in time. I will rewrite all this to be cleaner,
799    // but for now, it seems working fine
800    // (with the files I have, the results are equal to Voloview,
801    // and better than Deep Exploration and Lightwave).
802
803    // sanity check (useful when no block remains after all unsupported entities have been filtered out)
804    if (!_block)
805        return;
806
807    Matrixd back = sc->backMatrix();
808    Matrixd m;
809    m.makeIdentity();
810    sc->pushMatrix(m, true);
811    Vec3d trans = _block->getPosition();
812    sc->blockOffset(-trans);
813    if (_rotation) {
814        sc->pushMatrix(Matrixd::rotate(osg::DegreesToRadians(_rotation), 0,0,1));
815    }
816    sc->pushMatrix(Matrixd::scale(_scale.x(), _scale.y(), _scale.z()));
817    sc->pushMatrix(Matrixd::translate(_point.x(), _point.y(), _point.z()));
818    getOCSMatrix(_ocs, m);
819    sc->pushMatrix(m);
820    sc->pushMatrix(back);
821
822    EntityList& l = _block->getEntityList();
823    for (EntityList::iterator itr = l.begin(); itr != l.end(); ++itr) {
824        dxfBasicEntity* e = (*itr)->getEntity();
825        if (e) {
826            e->drawScene(sc);
827        }
828    }
829
830    sc->popMatrix(); // ocs
831    sc->popMatrix(); // translate
832    sc->popMatrix(); // scale
833    if (_rotation) {
834        sc->popMatrix(); // rotate
835    }
836    sc->popMatrix(); // identity
837    sc->popMatrix(); // back
838    sc->blockOffset(Vec3d(0,0,0));
839
840}
841
842void
843dxfText::assign(dxfFile* dxf, codeValue& cv)
844{
845    switch (cv._groupCode) {
846        case 1:
847            _string = cv._string;
848            break;
849        case 10:
850            _point1.x() = cv._double;
851            break;
852        case 20:
853            _point1.y() = cv._double;
854            break;
855        case 30:
856            _point1.z() = cv._double;
857            break;
858        case 11:
859            _point2.x() = cv._double;
860            break;
861        case 21:
862            _point2.y() = cv._double;
863            break;
864        case 31:
865            _point2.z() = cv._double;
866            break;
867        case 40:
868            _height = cv._double;
869            break;
870        case 41:
871            _xscale = cv._double;
872            break;
873        case 50:
874            _rotation = cv._double;
875            break;
876        case 71:
877            _flags = cv._int;
878            break;
879        case 72:
880            _hjustify = cv._int;
881            break;
882        case 73:
883            _vjustify = cv._int;
884            break;
885        case 210:
886            _ocs.x() = cv._double;
887            break;
888        case 220:
889            _ocs.y() = cv._double;
890            break;
891        case 230:
892            _ocs.z() = cv._double;
893            break;
894        default:
895            dxfBasicEntity::assign(dxf, cv);
896            break;
897    }
898}
899
900
901void
902dxfText::drawScene(scene* sc)
903{
904    osgText::Text::AlignmentType align;
905
906    Matrixd m;
907    getOCSMatrix(_ocs, m);
908    sc->ocs(m);
909
910    ref_ptr<osgText::Text> _text = new osgText::Text;
911    _text->setText(_string);
912
913    _text->setCharacterSize( _height, 1.0/_xscale );
914    _text->setFont("arial.ttf");
915
916    Quat qr( DegreesToRadians(_rotation), Z_AXIS );
917
918    if ( _flags & 2 ) qr = Quat( PI, Y_AXIS ) * qr;
919    if ( _flags & 4 ) qr = Quat( PI, X_AXIS ) * qr;
920
921    _text->setAxisAlignment(osgText::Text::USER_DEFINED_ROTATION);
922    _text->setRotation(qr);
923
924    if ( _hjustify != 0 || _vjustify !=0 ) _point1 = _point2;
925
926    switch (_vjustify) {
927    case 3:
928        switch (_hjustify) {
929        case 2:
930            align = osgText::Text::RIGHT_TOP;
931            break;
932        case 1:
933            align = osgText::Text::CENTER_TOP;
934            break;
935        default:
936            align = osgText::Text::LEFT_TOP;
937        }
938        break;
939    case 2:
940        switch (_hjustify) {
941        case 2:
942            align = osgText::Text::RIGHT_CENTER;
943            break;
944        case 1:
945            align = osgText::Text::CENTER_CENTER;
946            break;
947        default:
948            align = osgText::Text::LEFT_CENTER;
949        }
950        break;
951    case 1:
952        switch (_hjustify) {
953        case 2:
954            align = osgText::Text::RIGHT_BOTTOM;
955            break;
956        case 1:
957            align = osgText::Text::CENTER_BOTTOM;
958            break;
959        default:
960            align = osgText::Text::LEFT_BOTTOM;
961        }
962        break;
963    default:
964        switch (_hjustify) {
965        case 2:
966            align = osgText::Text::RIGHT_BOTTOM_BASE_LINE;
967            break;
968        case 1:
969            align = osgText::Text::CENTER_BOTTOM_BASE_LINE;
970            break;
971        default:
972            align = osgText::Text::LEFT_BOTTOM_BASE_LINE;
973        }
974        break;
975    }
976
977    _text->setAlignment(align);
978
979    sc->addText(getLayer(), _color, _point1, _text.get());
980    sc->ocs_clear();
981}
982
983
984// static
985void
986dxfEntity::registerEntity(dxfBasicEntity* entity)
987{
988    _registry[entity->name()] = entity;
989}
990
991// static
992void
993dxfEntity::unregisterEntity(dxfBasicEntity* entity)
994{
995    map<string, ref_ptr<dxfBasicEntity > >::iterator itr = _registry.find(entity->name());
996    if (itr != _registry.end()) {
997        _registry.erase(itr);
998    }
999}
1000
1001void dxfEntity::drawScene(scene* sc)
1002{
1003    for (std::vector<ref_ptr<dxfBasicEntity > >::iterator itr = _entityList.begin();
1004        itr != _entityList.end(); ++itr) {
1005            (*itr)->drawScene(sc);
1006    }
1007}
1008
1009void
1010dxfEntity::assign(dxfFile* dxf, codeValue& cv)
1011{
1012    string s = cv._string;
1013    if (cv._groupCode == 66 && !(_entity && string("TABLE") == _entity->name())) {
1014        // The funny thing here. Group code 66 has been called 'obsoleted'
1015        // for a POLYLINE. But not for an INSERT. Moreover, a TABLE
1016        // can have a 66 for... an obscure bottom cell color value.
1017        // I decided to rely on the presence of the 66 code for
1018        // the POLYLINE. If you find a better alternative,
1019        // contact me, or correct this code
1020        // and post the correction to osg mailing list
1021        _seqend = true;
1022    } else if (_seqend && cv._groupCode == 0 && s == "SEQEND") {
1023        _seqend = false;
1024//        cout << "... off" << endl;
1025    } else if (_entity) {
1026        _entity->assign(dxf, cv);
1027    }
1028}
Note: See TracBrowser for help on using the browser.