root/OpenSceneGraph/branches/OpenSceneGraph-2.8/src/osgPlugins/dxf/dxfEntity.cpp @ 11238

Revision 11238, 26.5 kB (checked in by paulmartz, 5 years ago)

2.8 branch: Minor bug fixes for ac and 3dc plugins. Merges these revisions from trunk: 10010, 10758, and 11175.

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