root/OpenSceneGraph/trunk/src/osgPlugins/shp/ESRIShape.cpp @ 13041

Revision 13041, 28.3 kB (checked in by robert, 15 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
2#if defined(_MSC_VER) || defined(__MINGW32__)
3    #include <stdio.h>
4    #include <io.h>
5
6    namespace esri
7    {
8        int read(int fd, void * buf, size_t nbytes) { return _read(fd, buf, static_cast<unsigned int>(nbytes)); }
9    }
10
11#else
12    #include <unistd.h>
13
14    namespace esri
15    {
16        int read(int fd, void * buf, size_t nbytes) { return ::read(fd, buf, nbytes); }
17    }
18
19#endif
20
21#include "ESRIShape.h"
22
23using namespace ESRIShape ;
24
25#define SAFE_DELETE_ARRAY( ptr ) delete[] ptr; ptr = 0L;
26
27template <class T>
28inline void swapBytes(  T &s )
29{
30    if( sizeof( T ) == 1 ) return;
31
32    T d = s;
33    BytePtr sptr = (BytePtr)&s;
34    BytePtr dptr = &(((BytePtr)&d)[sizeof(T)-1]);
35
36    for( unsigned int i = 0; i < sizeof(T); i++ )
37        *(sptr++) = *(dptr--);
38}
39
40inline ByteOrder getByteOrder()
41{
42    int one = 1;
43    unsigned char *ptr = (unsigned char *)&one;
44    if( ptr[0] == 1 )
45        return LittleEndian;
46    else
47        return BigEndian;
48}
49
50template <class T>
51inline bool readVal( int fd, T &val, ByteOrder bo = LittleEndian )
52{
53    int nbytes = 0;
54    if( (nbytes = esri::read( fd, &val, sizeof(T))) <= 0 )
55        return false;
56
57    if( getByteOrder() != bo )
58        swapBytes<T>(val);
59
60    return true;
61}
62
63inline void printType( ShapeType type )
64{
65    printf( "%s",
66        type == ShapeTypeNullShape   ? "NullShape" :
67        type == ShapeTypePoint       ? "Point" :
68        type == ShapeTypePolyLine    ? "PolyLine" :
69        type == ShapeTypePolygon     ? "Polygon" :
70        type == ShapeTypeMultiPoint  ? "MultiPoint" :
71        type == ShapeTypePointZ      ? "PointZ" :
72        type == ShapeTypePolyLineZ   ? "PolyLineZ" :
73        type == ShapeTypePolygonZ    ? "PolygonZ" :
74        type == ShapeTypeMultiPointZ ? "MultiPointZ" :
75        type == ShapeTypePointM      ? "PointM" :
76        type == ShapeTypePolyLineM   ? "PolyLineM" :
77        type == ShapeTypePolygonM    ? "PolygonM" :
78        type == ShapeTypeMultiPointM ? "MultiPointM" :
79        type == ShapeTypeMultiPatch  ? "MultiPatch" : "Unknown" );
80}
81
82
83bool BoundingBox::read( int fd )
84{
85    if( readVal<Double>(fd, Xmin, LittleEndian ) == false ) return false;
86    if( readVal<Double>(fd, Ymin, LittleEndian ) == false ) return false;
87    if( readVal<Double>(fd, Xmax, LittleEndian ) == false ) return false;
88    if( readVal<Double>(fd, Ymax, LittleEndian ) == false ) return false;
89    if( readVal<Double>(fd, Zmin, LittleEndian ) == false ) return false;
90    if( readVal<Double>(fd, Zmax, LittleEndian ) == false ) return false;
91    if( readVal<Double>(fd, Mmin, LittleEndian ) == false ) return false;
92    if( readVal<Double>(fd, Mmax, LittleEndian ) == false ) return false;
93
94    return true;
95}
96
97void BoundingBox::print()
98{
99    printf( "    Xmin: %G\n", Xmin );
100    printf( "    Ymin: %G\n", Ymin );
101    printf( "    Xmax: %G\n", Xmax );
102    printf( "    Ymax: %G\n", Ymax );
103    printf( "    Zmin: %G\n", Zmin );
104    printf( "    Zmax: %G\n", Zmax );
105    printf( "    Mmin: %G\n", Mmin );
106    printf( "    Mmax: %G\n", Mmax );
107}
108
109
110bool ShapeHeader::read(int fd)
111{
112    if( readVal<Integer>( fd, fileCode, BigEndian ) == false ) return false;
113    if( esri::read( fd, _unused_0, sizeof(_unused_0)) <= 0 ) return false;
114    if( readVal<Integer>( fd, fileLength, BigEndian ) == false ) return false;
115    if( readVal<Integer>( fd, version, LittleEndian ) == false ) return false;
116    if( readVal<Integer>( fd, shapeType, LittleEndian ) == false ) return false;
117    bbox.read(fd);
118    return true;
119}
120
121void ShapeHeader::print()
122{
123    printf( "File Code: %d\n", fileCode );
124    printf( "File Length: %d\n", fileLength );
125    printf( "Version: %d\n", version );
126    printf( "Shape Type: "); printType( ShapeType(shapeType) ); printf( "\n" );
127    printf( "Bounding Box:\n" );
128    bbox.print();
129}
130
131RecordHeader::RecordHeader():
132    recordNumber(-1),
133    contentLength(0)
134{
135}
136
137bool RecordHeader::read( int fd )
138{
139    if( readVal<Integer>( fd, recordNumber, BigEndian ) == false ) return false;
140    if( readVal<Integer>( fd, contentLength, BigEndian ) == false ) return false;
141    return true;
142}
143
144void RecordHeader::print()
145{
146    printf( " Record Number: %d\n", recordNumber );
147    printf( "Content Length: %d\n", contentLength );
148}
149
150
151
152NullRecord::NullRecord():
153    shapeType(ShapeTypeNullShape)
154{}
155
156bool NullRecord::read( int fd )
157{
158    if( readVal<Integer>( fd, shapeType, LittleEndian ) == false ) return false;
159    return true;
160}
161
162
163Box::Box() {}
164Box::Box(const Box &b ):
165    Xmin(b.Xmin),
166    Ymin(b.Ymin),
167    Xmax(b.Xmax),
168    Ymax(b.Ymax)
169    {}
170
171bool Box::read( int fd )
172{
173    if( readVal<Double>(fd, Xmin, LittleEndian) == false ) return false;
174    if( readVal<Double>(fd, Ymin, LittleEndian) == false ) return false;
175    if( readVal<Double>(fd, Xmax, LittleEndian) == false ) return false;
176    if( readVal<Double>(fd, Ymax, LittleEndian) == false ) return false;
177    return true;
178}
179
180Range::Range() {}
181Range::Range( const Range &r ): min(r.min), max(r.max) {}
182
183bool Range::read( int fd )
184{
185    if( readVal<Double>(fd, min, LittleEndian ) == false ) return false;
186    if( readVal<Double>(fd, max, LittleEndian ) == false ) return false;
187    return true;
188}
189
190ShapeObject::ShapeObject(ShapeType s):
191    shapeType(s)
192{}
193
194ShapeObject::~ShapeObject()
195{ }
196
197
198
199Point::Point():
200    ShapeObject(ShapeTypePoint),
201    x(0.0),
202    y(0.0)
203{}
204
205Point::Point(const Point &p):
206    ShapeObject(ShapeTypePoint),
207    x(p.x),
208    y(p.y)
209{}
210
211Point::~Point() {}
212
213bool Point::read( int fd )
214{
215
216    if( readVal<Double>( fd, x, LittleEndian ) == false ) return false;
217    if( readVal<Double>( fd, y, LittleEndian ) == false ) return false;
218
219    return true;
220}
221
222bool PointRecord::read( int fd )
223{
224    RecordHeader rh;
225    if( rh.read(fd) == false )
226        return false;
227
228    Integer shapeType;
229    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
230        return false;
231
232    if( shapeType != ShapeTypePoint )
233        return false;
234
235    return point.read(fd);
236}
237
238void Point::print()
239{
240    printf( "    %G %G\n", x, y );
241}
242
243MultiPoint::MultiPoint():
244    ShapeObject(ShapeTypeMultiPoint),
245    numPoints(0),
246    points(0L)
247{}
248
249MultiPoint::MultiPoint( const struct MultiPoint &mpoint ): ShapeObject(ShapeTypeMultiPoint),
250    bbox(mpoint.bbox),
251    numPoints(mpoint.numPoints)
252{
253    points = new Point[numPoints];
254    for( int i = 0; i < numPoints; i++ )
255        points[i] = mpoint.points[i];
256}
257
258MultiPoint::~MultiPoint()
259{
260    delete[] points;
261}
262
263bool MultiPoint::read( int fd )
264{
265    RecordHeader rh;
266    if( rh.read(fd) == false )
267        return false;
268
269    SAFE_DELETE_ARRAY( points );
270
271    Integer shapeType;
272    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
273        return false;
274
275    if( shapeType != ShapeTypeMultiPoint )
276        return false;
277
278    if( bbox.read(fd) == false )
279        return false;
280
281    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
282        return false;
283
284    points = new struct Point[numPoints];
285    for( Integer i = 0; i < numPoints; i++ )
286    {
287        if( points[i].read(fd) == false )
288            return false;
289    }
290    return true;
291}
292
293void MultiPoint::print()
294{
295    printf( "Point - numPoints: %d\n", numPoints );
296    for( int i= 0; i < numPoints; i++ )
297        points[i].print();
298}
299
300
301
302PolyLine::PolyLine():
303    ShapeObject(ShapeTypePolyLine),
304    numParts(0),
305    numPoints(0),
306    parts(0L),
307    points(0L) {}
308
309PolyLine::PolyLine( const PolyLine &p ):
310    ShapeObject(ShapeTypePolyLine),
311    numParts(p.numParts),
312    numPoints(p.numPoints)
313{
314    parts = new Integer[numParts];
315    Integer i;
316    for(i = 0; i < numParts; i++ )
317        parts[i] = p.parts[i];
318
319    points = new Point[numPoints];
320    for(i = 0; i < numPoints; i++ )
321        points[i] = p.points[i];
322}
323
324PolyLine::~PolyLine()
325{
326    delete [] parts;
327    delete [] points;
328}
329
330bool PolyLine::read( int fd )
331{
332    RecordHeader rh;
333    if( rh.read(fd) == false )
334        return false;
335
336    SAFE_DELETE_ARRAY( parts );
337    SAFE_DELETE_ARRAY( points );
338
339    Integer shapeType;
340    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
341        return false;
342
343    if( shapeType != ShapeTypePolyLine )
344        return false;
345
346    if( bbox.read(fd) == false )
347        return false;
348
349    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
350        return false;
351
352    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
353        return false;
354
355    parts  = new Integer[numParts];
356    int i;
357    for( i = 0; i < numParts; i++ )
358    {
359        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
360            return false;
361
362    }
363    points = new struct Point[numPoints];
364    for( i = 0; i < numPoints; i++ )
365    {
366        if( points[i].read(fd ) == false )
367            return false;
368    }
369    return true;
370}
371
372
373Polygon::Polygon():
374    ShapeObject(ShapeTypePolygon),
375    numParts(0),
376    numPoints(0),
377    parts(0L),
378    points(0L) {}
379
380    Polygon::Polygon( const Polygon &p ):
381    ShapeObject(ShapeTypePolygon),
382    numParts(p.numParts),
383    numPoints(p.numPoints)
384{
385    parts = new Integer[numParts];
386    Integer i;
387    for( i = 0; i < numParts; i++ )
388        parts[i] = p.parts[i];
389
390    points = new Point[numPoints];
391    for( i = 0; i < numPoints; i++ )
392        points[i] = p.points[i];
393}
394
395Polygon::~Polygon()
396{
397    delete [] parts;
398    delete [] points;
399}
400
401
402bool Polygon::read( int fd )
403{
404    RecordHeader rh;
405    if( rh.read(fd) == false )
406        return false;
407
408    SAFE_DELETE_ARRAY( parts );
409    SAFE_DELETE_ARRAY( points );
410
411    Integer shapeType;
412    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
413        return false;
414
415    if( shapeType != ShapeTypePolygon )
416        return false;
417
418    if( bbox.read(fd) == false )
419        return false;
420
421    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
422        return false;
423
424    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
425        return false;
426
427    parts  = new Integer[numParts];
428    int i;
429    for( i = 0; i < numParts; i++ )
430    {
431        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
432            return false;
433    }
434    points = new struct Point[numPoints];
435    for( i = 0; i < numPoints; i++ )
436    {
437        if( points[i].read(fd ) == false )
438            return false;
439    }
440    return true;
441}
442
443//////////////////////////////////////////////////////////////////////
444
445PointM::PointM():
446    ShapeObject(ShapeTypePointM),
447    x(0.0),
448    y(0.0),
449    m(0.0)
450{}
451
452PointM::PointM(const PointM &p):
453    ShapeObject(ShapeTypePointM),
454    x(p.x),
455    y(p.y),
456    m(p.m)
457{}
458
459PointM::~PointM() {}
460
461bool PointM::read( int fd )
462{
463    if( readVal<Double>( fd, x, LittleEndian ) == false ) return false;
464    if( readVal<Double>( fd, y, LittleEndian ) == false ) return false;
465    if( readVal<Double>( fd, m, LittleEndian ) == false ) return false;
466
467    return true;
468}
469
470void PointM::print()
471{
472    printf( "    %G %G (%G)\n", x, y, m );
473}
474
475bool PointMRecord::read( int fd )
476{
477    RecordHeader rh;
478    if( rh.read(fd) == false )
479        return false;
480
481    Integer shapeType;
482    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
483        return false;
484
485    if( shapeType != ShapeTypePointM )
486        return false;
487
488    return pointM.read(fd);
489}
490
491
492MultiPointM::MultiPointM():
493    ShapeObject(ShapeTypeMultiPointM),
494    numPoints(0),
495    points(0L),
496    mArray(0L)
497{}
498
499    MultiPointM::MultiPointM( const struct MultiPointM &mpointm ):
500    ShapeObject(ShapeTypeMultiPointM),
501    bbox(mpointm.bbox),
502    numPoints(mpointm.numPoints),
503    mRange(mpointm.mRange)
504{
505    points = new Point[numPoints];
506    mArray = new Double[numPoints];
507    for( int i = 0; i < numPoints; i++ )
508    {
509        points[i] = mpointm.points[i];
510        mArray[i] = mpointm.mArray[i];
511    }
512}
513
514MultiPointM::~MultiPointM()
515{
516    delete [] points;
517    delete [] mArray;
518}
519
520bool MultiPointM::read( int fd )
521{
522    RecordHeader rh;
523    if( rh.read(fd) == false )
524        return false;
525
526    SAFE_DELETE_ARRAY( points );
527    SAFE_DELETE_ARRAY( mArray );
528
529    Integer shapeType;
530    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
531        return false;
532
533    if( shapeType != ShapeTypeMultiPointM )
534        return false;
535
536    if( bbox.read(fd) == false )
537        return false;
538
539    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
540        return false;
541
542    points = new struct Point[numPoints];
543    Integer i;
544    for( i = 0; i < numPoints; i++ )
545    {
546        if( points[i].read(fd) == false )
547            return false;
548    }
549
550    int X = 40 + (16 * numPoints);
551    if( rh.contentLength > X )
552    {
553        if( mRange.read(fd) == false )
554            return false;
555
556        mArray = new Double[numPoints];
557        for( i = 0; i < numPoints; i++ )
558        {
559            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
560                return false;
561        }
562    }
563
564    return true;
565}
566
567void MultiPointM::print()
568{
569    printf( "Point - numPoints: %d\n", numPoints );
570    for( int i= 0; i < numPoints; i++ )
571        points[i].print();
572}
573
574PolyLineM::PolyLineM():
575    ShapeObject(ShapeTypePolyLineM),
576    numParts(0),
577    numPoints(0),
578    parts(0L),
579    points(0L),
580    mArray(0L)
581{}
582
583PolyLineM::PolyLineM(const PolyLineM &p):
584    ShapeObject(ShapeTypePolyLineM),
585    numParts(p.numParts),
586    numPoints(p.numPoints),
587    parts(0L),
588    points(0L),
589    mArray(0L)
590{
591    parts = new Integer[numParts];
592    Integer i;
593    for( i = 0; i < numParts; i++ )
594        parts[i] = p.parts[i];
595
596    points = new Point[numPoints];
597    mArray = new Double[numPoints];
598    for( i = 0; i < numPoints; i++ )
599    {
600        points[i] = p.points[i];
601        mArray[i] = p.mArray[i];
602    }
603}
604
605PolyLineM::~PolyLineM()
606{
607    delete [] parts;
608    delete [] points;
609    delete [] mArray;
610}
611
612bool PolyLineM::read( int fd )
613{
614    RecordHeader rh;
615    if( rh.read(fd) == false )
616        return false;
617
618    SAFE_DELETE_ARRAY( parts );
619    SAFE_DELETE_ARRAY( points );
620    SAFE_DELETE_ARRAY( mArray );
621
622    Integer shapeType;
623    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
624        return false;
625
626    if( shapeType != ShapeTypePolyLineM )
627        return false;
628
629    if( bbox.read(fd) == false )
630        return false;
631
632    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
633        return false;
634
635    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
636        return false;
637
638    parts  = new Integer[numParts];
639    int i;
640    for( i = 0; i < numParts; i++ )
641    {
642        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
643            return false;
644
645    }
646    points = new struct Point[numPoints];
647    for( i = 0; i < numPoints; i++ )
648    {
649        if( points[i].read(fd ) == false )
650            return false;
651    }
652
653    int X = 44 + (4 * numParts);
654    int Y = X + (16 * numPoints);
655
656    if( rh.contentLength > Y )
657    {
658        mRange.read(fd);
659        mArray = new Double[numPoints];
660        for( i = 0; i < numPoints; i++  )
661        {
662            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
663                return false;
664        }
665    }
666
667    return true;
668}
669
670
671PolygonM::PolygonM():
672    ShapeObject(ShapeTypePolygonM),
673    numParts(0),
674    numPoints(0),
675    parts(0L),
676    points(0L) ,
677    mArray(0L)
678{}
679
680PolygonM::PolygonM(const PolygonM &p):
681    ShapeObject(ShapeTypePolygonM),
682    numParts(p.numParts),
683    numPoints(p.numPoints),
684    parts(0L),
685    points(0L) ,
686    mArray(0L)
687{
688    parts = new Integer[numParts];
689    Integer i;
690    for( i = 0; i < numParts; i++ )
691        parts[i] = p.parts[i];
692
693    points = new Point[numPoints];
694    mArray = new Double[numPoints];
695    for( i = 0; i < numPoints; i++ )
696    {
697        points[i] = p.points[i];
698        mArray[i] = p.mArray[i];
699    }
700}
701
702PolygonM::~PolygonM()
703{
704    delete[] parts;
705    delete[] points;
706    delete[] mArray;
707}
708
709
710bool PolygonM::read( int fd )
711{
712    RecordHeader rh;
713    if( rh.read(fd) == false )
714        return false;
715
716    SAFE_DELETE_ARRAY( parts );
717    SAFE_DELETE_ARRAY( points );
718    SAFE_DELETE_ARRAY( mArray );
719
720    Integer shapeType;
721    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
722        return false;
723
724    if( shapeType != ShapeTypePolygonM )
725        return false;
726
727    if( bbox.read(fd) == false )
728        return false;
729
730    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
731        return false;
732
733    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
734        return false;
735
736    parts  = new Integer[numParts];
737    int i;
738    for( i = 0; i < numParts; i++ )
739    {
740        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
741            return false;
742    }
743    points = new struct Point[numPoints];
744    for( i = 0; i < numPoints; i++ )
745    {
746        if( points[i].read(fd ) == false )
747            return false;
748    }
749
750    int X = 44 + (4 * numParts);
751    int Y = X + (16 * numPoints);
752
753    if( rh.contentLength > Y )
754    {
755        if( mRange.read(fd) == false )
756            return false;
757
758        mArray = new Double[numPoints];
759        for( i = 0; i < numPoints; i++ )
760        {
761            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
762                return false;
763        }
764    }
765
766    return true;
767}
768
769
770//////////////////////////////////////////////////////////////////////
771
772PointZ::PointZ():
773    ShapeObject(ShapeTypePointZ),
774    x(0.0),
775    y(0.0),
776    z(0.0),
777    m(0.0)
778{}
779
780PointZ::PointZ(const PointZ &p):
781    ShapeObject(ShapeTypePointZ),
782    x(p.x),
783    y(p.y),
784    z(p.z),
785    m(p.m)
786{}
787
788PointZ::~PointZ() {}
789
790bool PointZ::read( int fd )
791{
792    RecordHeader rh;
793    if( rh.read(fd) == false )
794        return false;
795
796    Integer shapeType;
797    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
798        return false;
799
800    if( shapeType != ShapeTypePointZ )
801        return false;
802
803    if( readVal<Double>( fd, x, LittleEndian ) == false )
804        return false;
805
806    if( readVal<Double>( fd, y, LittleEndian ) == false )
807        return false;
808
809    if( readVal<Double>( fd, z, LittleEndian ) == false )
810        return false;
811
812    // Sometimes, M field is not supplied
813    if( rh.contentLength >= 18 )
814        if( readVal<Double>( fd, m, LittleEndian ) == false )
815            return false;
816
817    return true;
818}
819
820void PointZ::print()
821{
822    printf( "    %G %G %G (%G)\n", x, y, z, m );
823}
824
825MultiPointZ::MultiPointZ():
826    ShapeObject(ShapeTypeMultiPointZ),
827    numPoints(0),
828    points(0L),
829    zArray(0L),
830    mArray(0L)
831    {}
832
833MultiPointZ::MultiPointZ( const struct MultiPointZ &mpointm ):
834    ShapeObject(ShapeTypeMultiPointZ),
835    bbox(mpointm.bbox),
836    numPoints(mpointm.numPoints),
837    zRange(mpointm.zRange),
838    mRange(mpointm.mRange)
839{
840    points = new Point[numPoints];
841    zArray = new Double[numPoints];
842    mArray = new Double[numPoints];
843    for( int i = 0; i < numPoints; i++ )
844    {
845        points[i] = mpointm.points[i];
846        zArray[i] = mpointm.zArray[i];
847        mArray[i] = mpointm.mArray[i];
848    }
849}
850
851MultiPointZ::~MultiPointZ()
852{
853    delete [] points;
854    delete [] zArray;
855    delete [] mArray;
856}
857
858bool MultiPointZ::read( int fd )
859{
860    RecordHeader rh;
861    if( rh.read(fd) == false )
862        return false;
863
864    SAFE_DELETE_ARRAY( points );
865    SAFE_DELETE_ARRAY( zArray );
866    SAFE_DELETE_ARRAY( mArray );
867
868    Integer shapeType;
869    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
870        return false;
871
872    if( shapeType != ShapeTypeMultiPointZ )
873        return false;
874
875    if( bbox.read(fd) == false )
876        return false;
877
878    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
879        return false;
880
881    points = new struct Point[numPoints];
882    Integer i;
883    for( i = 0; i < numPoints; i++ )
884    {
885        if( points[i].read(fd) == false )
886            return false;
887    }
888
889    if( zRange.read(fd) == false )
890        return false;
891
892    zArray = new Double[numPoints];
893    for( i = 0; i < numPoints; i++ )
894    {
895        if( readVal<Double>(fd, zArray[i], LittleEndian) == false )
896            return false;
897    }
898
899    int X = 40 + (16*numPoints);
900    int Y = X + 16 + (8*numPoints);
901    if( rh.contentLength > Y )
902    {
903        if( mRange.read(fd) == false )
904            return false;
905
906        mArray = new Double[numPoints];
907        for( i = 0; i < numPoints; i++ )
908        {
909            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
910                return false;
911        }
912    }
913
914    return true;
915}
916
917void MultiPointZ::print()
918{
919    printf( "Point - numPoints: %d\n", numPoints );
920    for( int i= 0; i < numPoints; i++ )
921        points[i].print();
922}
923
924
925PolyLineZ::PolyLineZ():
926    ShapeObject(ShapeTypePolyLineZ),
927    numParts(0),
928    numPoints(0),
929    parts(0L),
930    points(0L),
931    zArray(0L) ,
932    mArray(0L)
933{}
934
935PolyLineZ::PolyLineZ(const PolyLineZ &p):
936    ShapeObject(ShapeTypePolyLineZ),
937    numParts(p.numParts),
938    numPoints(p.numPoints),
939    parts(0L),
940    points(0L),
941    zArray(0L) ,
942    mArray(0L)
943{
944    parts = new Integer[numParts];
945    Integer i;
946    for( i = 0; i < numParts; i++ )
947        parts[i] = p.parts[i];
948
949    points = new Point[numPoints];
950    zArray = new Double[numPoints];
951    for( i = 0; i < numPoints; i++ )
952    {
953        points[i] = p.points[i];
954        zArray[i] = p.zArray[i];
955    }
956
957    // Sometimes, M Array is not present on the file
958    if( p.mArray != NULL )
959    {
960        mArray = new Double[numPoints];
961        for( i = 0; i < numPoints; i++ )
962            mArray[i] = p.mArray[i];
963    }
964}
965
966PolyLineZ::~PolyLineZ()
967{
968    delete [] parts;
969    delete [] points;
970    delete [] zArray;
971    delete [] mArray;
972}
973
974bool PolyLineZ::read( int fd )
975{
976    RecordHeader rh;
977    if( rh.read(fd) == false )
978        return false;
979
980    SAFE_DELETE_ARRAY( parts );
981    SAFE_DELETE_ARRAY( points );
982    SAFE_DELETE_ARRAY( zArray );
983    SAFE_DELETE_ARRAY( mArray );
984
985    Integer shapeType;
986    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
987        return false;
988
989    if( shapeType != ShapeTypePolyLineZ )
990        return false;
991
992    if( bbox.read(fd) == false )
993        return false;
994
995    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
996        return false;
997
998    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
999        return false;
1000
1001    parts  = new Integer[numParts];
1002    int i;
1003    for( i = 0; i < numParts; i++ )
1004    {
1005        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
1006            return false;
1007
1008    }
1009    points = new struct Point[numPoints];
1010    for( i = 0; i < numPoints; i++ )
1011    {
1012        if( points[i].read(fd ) == false )
1013            return false;
1014    }
1015
1016    zRange.read(fd);
1017    zArray = new Double[numPoints];
1018    for( i = 0; i < numPoints; i++ )
1019    {
1020        if( readVal<Double>(fd, zArray[i], LittleEndian ) == false )
1021            return false;
1022    }
1023
1024    int X = 44 + (4 * numParts);
1025    int Y = X + (15 * numPoints);
1026    int Z = Y + 16 + (8 * numPoints);
1027
1028    if( rh.contentLength != Z )
1029    {
1030        mRange.read(fd);
1031        mArray = new Double[numPoints];
1032        for( i = 0; i < numPoints; i++ )
1033        {
1034            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
1035                return false;
1036        }
1037    }
1038
1039    return true;
1040}
1041
1042
1043PolygonZ::PolygonZ():
1044    ShapeObject(ShapeTypePolygonZ),
1045    numParts(0),
1046    numPoints(0),
1047    parts(0L),
1048    points(0L),
1049    zArray(0L),
1050    mArray(0L)
1051{}
1052
1053PolygonZ::PolygonZ(const PolygonZ &p):
1054    ShapeObject(ShapeTypePolygonZ),
1055    numParts(p.numParts),
1056    numPoints(p.numPoints),
1057    parts(0L),
1058    points(0L) ,
1059    mArray(0L)
1060{
1061    parts = new Integer[numParts];
1062    Integer i;
1063    for( i = 0; i < numParts; i++ )
1064        parts[i] = p.parts[i];
1065
1066    points = new Point[numPoints];
1067    zArray = new Double[numPoints]; // jcm
1068    mArray = new Double[numPoints];
1069    for( i = 0; i < numPoints; i++ )
1070    {
1071        points[i] = p.points[i];
1072        zArray[i] = p.zArray[i]; // jcm
1073    // M-Array seems to be missing sometimes
1074    if(p.mArray)
1075        mArray[i] = p.mArray[i];
1076    }
1077}
1078
1079PolygonZ::~PolygonZ()
1080{
1081    delete [] parts;
1082    delete [] points;
1083    delete [] zArray;
1084    delete [] mArray;
1085}
1086
1087bool PolygonZ::read( int fd )
1088{
1089    RecordHeader rh;
1090    if( rh.read(fd) == false )
1091        return false;
1092
1093    SAFE_DELETE_ARRAY( parts );
1094    SAFE_DELETE_ARRAY( points );
1095    SAFE_DELETE_ARRAY( zArray );
1096    SAFE_DELETE_ARRAY( mArray );
1097
1098    Integer shapeType;
1099    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
1100        return false;
1101
1102    if( shapeType != ShapeTypePolygonZ )
1103        return false;
1104
1105    if( bbox.read(fd) == false )
1106        return false;
1107
1108    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
1109        return false;
1110
1111    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
1112        return false;
1113
1114    parts  = new Integer[numParts];
1115    int i;
1116    for( i = 0; i < numParts; i++ )
1117    {
1118        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
1119            return false;
1120    }
1121    points = new struct Point[numPoints];
1122    for( i = 0; i < numPoints; i++ )
1123    {
1124        if( points[i].read(fd ) == false )
1125            return false;
1126    }
1127
1128    if( zRange.read(fd) == false )
1129        return false;
1130
1131    zArray = new Double[numPoints];
1132    for( i = 0; i < numPoints; i++ )
1133    {
1134        if( readVal<Double>(fd, zArray[i], LittleEndian ) == false )
1135            return false;
1136    }
1137
1138    int  X = 44 + (4*numParts);
1139    int  Y = X + (16*numPoints);
1140    int  Z = Y + 16 + (8*numPoints);
1141    if( rh.contentLength != Z )
1142    {
1143        if( mRange.read(fd) == false )
1144            return false;
1145
1146        mArray = new Double[numPoints];
1147        for( i = 0; i < numPoints; i++ )
1148        {
1149            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
1150                return false;
1151        }
1152    }
1153
1154    return true;
1155}
1156
1157
1158//////////////////////////////////////////////////////////////////////
1159
1160/*
1161struct MultiPatch
1162{
1163    Box             bbox;
1164    Integer         numParts;
1165    Integer         numPoints;
1166    Integer         *parts;
1167    Integer         *partTypes;
1168    struct Point    *points;
1169    Range           zRange;
1170    Double          *zArray;
1171    Range           mRange;
1172    Double          *mArray;
1173
1174    MultiPatch();
1175    MultiPatch( const MultiPatch &);
1176    virtual ~MultiPatch();
1177    bool read( fd );
1178};
1179*/
1180
1181MultiPatch::MultiPatch():
1182    numParts(0),
1183    numPoints(0),
1184    parts(0L),
1185    partTypes(0L),
1186    points(0L),
1187    zArray(0L),
1188    mArray(0L)
1189{ }
1190
1191MultiPatch::MultiPatch( const MultiPatch &mp):
1192    bbox(mp.bbox),
1193    numParts(mp.numParts),
1194    numPoints(mp.numPoints),
1195    zRange(mp.zRange),
1196    mRange(mp.mRange)
1197{
1198    parts = new Integer[numParts];
1199    partTypes = new Integer[numParts];
1200    Integer i;
1201    for( i = 0; i < numParts; i++ )
1202    {
1203        parts[i] = mp.parts[i];
1204        partTypes[i] = mp.partTypes[i];
1205    }
1206    points = new Point[numPoints];
1207    zArray = new Double[numPoints];
1208    mArray = new Double[numPoints];
1209    for( i = 0; i < numPoints; i++ )
1210    {
1211        points[i] = mp.points[i];
1212        zArray[i] = mp.zArray[i];
1213        if( mp.mArray != 0L )
1214            mArray[i] = mp.mArray[i];
1215    }
1216}
1217
1218MultiPatch::~MultiPatch()
1219{
1220    delete [] parts;
1221    delete [] partTypes;
1222    delete [] points;
1223    delete [] zArray;
1224    delete [] mArray;
1225}
1226
1227bool MultiPatch::read( int fd )
1228{
1229    RecordHeader rh;
1230    if( rh.read(fd) == false )
1231        return false;
1232
1233    SAFE_DELETE_ARRAY( parts );
1234    SAFE_DELETE_ARRAY( partTypes );
1235    SAFE_DELETE_ARRAY( points );
1236    SAFE_DELETE_ARRAY( zArray );
1237    SAFE_DELETE_ARRAY( mArray );
1238
1239    Integer shapeType;
1240    if( readVal<Integer>(fd, shapeType, LittleEndian ) == false )
1241        return false;
1242
1243    if( shapeType != ShapeTypeMultiPatch )
1244        return false;
1245
1246    if( bbox.read(fd) == false )
1247        return false;
1248
1249    if( readVal<Integer>(fd, numParts, LittleEndian ) == false )
1250        return false;
1251
1252    if( readVal<Integer>(fd, numPoints, LittleEndian ) == false )
1253        return false;
1254
1255    parts  = new Integer[numParts];
1256    int i;
1257    for( i = 0; i < numParts; i++ )
1258    {
1259        if( readVal<Integer>(fd, parts[i], LittleEndian ) == false )
1260            return false;
1261    }
1262
1263    partTypes = new Integer[numParts];
1264    for( i = 0; i < numParts; i++ )
1265    {
1266        if( readVal<Integer>(fd, partTypes[i], LittleEndian ) == false )
1267            return false;
1268    }
1269
1270    points = new struct Point[numPoints];
1271    for( i = 0; i < numPoints; i++ )
1272    {
1273        if( points[i].read(fd ) == false )
1274            return false;
1275    }
1276
1277    if( zRange.read(fd) == false )
1278        return false;
1279
1280    zArray = new Double[numPoints];
1281    for( i = 0; i < numPoints; i++ )
1282    {
1283        if( readVal<Double>(fd, zArray[i], LittleEndian ) == false )
1284            return false;
1285    }
1286
1287    int  W = 44 + (4*numParts);
1288    int  X = W + (4 * numParts);
1289    int  Y = X + (16 *numPoints);
1290    int  Z = Y + 16 + (8 *numPoints);
1291    if( rh.contentLength > Z )
1292    {
1293        if( mRange.read(fd) == false )
1294            return false;
1295
1296        mArray = new Double[numPoints];
1297        for( i = 0; i < numPoints; i++ )
1298        {
1299            if( readVal<Double>(fd, mArray[i], LittleEndian ) == false )
1300                return false;
1301        }
1302    }
1303
1304    return true;
1305}
1306
Note: See TracBrowser for help on using the browser.