Line data Source code
1 : /******************************************************************************
2 : *
3 : * Project: SDTS Translator
4 : * Purpose: Include file for entire SDTS Abstraction Layer functions.
5 : * Author: Frank Warmerdam, warmerdam@pobox.com
6 : *
7 : ******************************************************************************
8 : * Copyright (c) 1999, Frank Warmerdam
9 : *
10 : * SPDX-License-Identifier: MIT
11 : ****************************************************************************/
12 :
13 : #ifndef SDTS_AL_H_INCLUDED
14 : #define SDTS_AL_H_INCLUDED
15 :
16 : #include "cpl_conv.h"
17 : #include "iso8211.h"
18 :
19 : class SDTS_IREF;
20 : class SDTSModId;
21 : class SDTSTransfer;
22 :
23 : #define SDTS_SIZEOF_SADR 8
24 :
25 : char **SDTSScanModuleReferences(DDFModule *, const char *);
26 :
27 : /************************************************************************/
28 : /* SDTS_IREF */
29 : /************************************************************************/
30 :
31 : /**
32 : Class holding SDTS IREF (internal reference) information, internal
33 : coordinate system format, scaling and resolution. This object isn't
34 : normally needed by applications.
35 : */
36 : class SDTS_IREF
37 : {
38 : int nDefaultSADRFormat;
39 :
40 : public:
41 : SDTS_IREF();
42 : ~SDTS_IREF();
43 :
44 : int Read(const char *pszFilename);
45 :
46 : char *pszXAxisName; /* XLBL */
47 : char *pszYAxisName; /* YLBL */
48 :
49 : double dfXScale; /* SFAX */
50 : double dfYScale; /* SFAY */
51 :
52 : double dfXOffset; /* XORG */
53 : double dfYOffset; /* YORG */
54 :
55 : double dfXRes; /* XHRS */
56 : double dfYRes; /* YHRS */
57 :
58 : char *pszCoordinateFormat; /* HFMT */
59 :
60 : int GetSADRCount(DDFField *) const;
61 : int GetSADR(DDFField *, int, double *, double *, double *);
62 : };
63 :
64 : /************************************************************************/
65 : /* SDTS_XREF */
66 : /************************************************************************/
67 :
68 : /**
69 : Class for reading the XREF (external reference) module containing the
70 : data projection definition.
71 : */
72 :
73 : class SDTS_XREF
74 : {
75 : public:
76 : SDTS_XREF();
77 : ~SDTS_XREF();
78 :
79 : int Read(const char *pszFilename);
80 :
81 : /** Projection system name, from the RSNM field. One of GEO, SPCS, UTM,
82 : UPS, OTHR, UNSP. */
83 : char *pszSystemName;
84 :
85 : /** Horizontal datum name, from the HDAT field. One of NAS, NAX, WGA,
86 : WGB, WGC, WGE. */
87 : char *pszDatum;
88 :
89 : /** Zone number for UTM and SPCS projections, from the ZONE field. */
90 : int nZone;
91 : };
92 :
93 : /************************************************************************/
94 : /* SDTS_CATD */
95 : /************************************************************************/
96 : class SDTS_CATDEntry;
97 :
98 : /**
99 : List of feature layer types. See SDTSTransfer::GetLayerType().
100 : */
101 :
102 : typedef enum
103 : {
104 : SLTUnknown,
105 : SLTPoint,
106 : SLTLine,
107 : SLTAttr,
108 : SLTPoly,
109 : SLTRaster
110 : } SDTSLayerType;
111 :
112 : /**
113 : Class for accessing the CATD (Catalog Directory) file containing a list of
114 : all other files (modules) in the transfer.
115 : */
116 : class SDTS_CATD
117 : {
118 : char *pszPrefixPath;
119 :
120 : int nEntries;
121 : SDTS_CATDEntry **papoEntries;
122 :
123 : public:
124 : SDTS_CATD();
125 : ~SDTS_CATD();
126 :
127 : int Read(const char *pszFilename);
128 :
129 : const char *GetModuleFilePath(const char *pszModule) const;
130 :
131 69 : int GetEntryCount() const
132 : {
133 69 : return nEntries;
134 : }
135 :
136 : const char *GetEntryModule(int) const;
137 : const char *GetEntryTypeDesc(int) const;
138 : const char *GetEntryFilePath(int) const;
139 : SDTSLayerType GetEntryType(int) const;
140 : void SetEntryTypeUnknown(int);
141 : };
142 :
143 : /************************************************************************/
144 : /* SDTSModId */
145 : /************************************************************************/
146 :
147 : /**
148 : Object representing a unique module/record identifier within an SDTS
149 : transfer.
150 : */
151 : class SDTSModId
152 : {
153 : public:
154 1290 : SDTSModId()
155 1290 : {
156 1290 : szModule[0] = '\0';
157 1290 : nRecord = -1;
158 1290 : szOBRP[0] = '\0';
159 1290 : szName[0] = '\0';
160 1290 : }
161 :
162 : int Set(DDFField *);
163 :
164 : const char *GetName();
165 :
166 : /** The module name, such as PC01, containing the indicated record. */
167 : char szModule[8];
168 :
169 : /** The record within the module referred to. This is -1 for unused
170 : SDTSModIds. */
171 : int nRecord;
172 :
173 : /** The "role" of this record within the module. This is normally empty
174 : for references, but set in the oModId member of a feature. */
175 : char szOBRP[8];
176 :
177 : /** String "szModule:nRecord" */
178 : char szName[20];
179 : };
180 :
181 : /************************************************************************/
182 : /* SDTSFeature */
183 : /************************************************************************/
184 :
185 : /**
186 : Base class for various SDTS features classes, providing a generic
187 : module identifier, and list of attribute references.
188 : */
189 : class SDTSFeature
190 : {
191 : public:
192 : SDTSFeature();
193 : virtual ~SDTSFeature();
194 :
195 : /** Unique identifier for this record/feature within transfer. */
196 : SDTSModId oModId;
197 :
198 : /** Number of attribute links (aoATID[]) on this feature. */
199 : int nAttributes;
200 :
201 : /** List of nAttributes attribute record identifiers related to this
202 : feature. */
203 : SDTSModId *paoATID;
204 :
205 : void ApplyATID(DDFField *);
206 :
207 : /** Dump readable description of feature to indicated stream. */
208 : virtual void Dump(FILE *) = 0;
209 : };
210 :
211 : /************************************************************************/
212 : /* SDTSIndexedReader */
213 : /************************************************************************/
214 :
215 : /**
216 : Base class for all the SDTSFeature type readers. Provides feature
217 : caching semantics and fetching based on a record number.
218 : */
219 :
220 : class SDTSIndexedReader
221 : {
222 : int nIndexSize;
223 : SDTSFeature **papoFeatures;
224 :
225 : int iCurrentFeature;
226 :
227 : protected:
228 : DDFModule oDDFModule;
229 :
230 : public:
231 : SDTSIndexedReader();
232 : virtual ~SDTSIndexedReader();
233 :
234 : virtual SDTSFeature *GetNextRawFeature() = 0;
235 :
236 : SDTSFeature *GetNextFeature();
237 :
238 : virtual void Rewind();
239 :
240 : void FillIndex();
241 : void ClearIndex();
242 : int IsIndexed() const;
243 :
244 : SDTSFeature *GetIndexedFeatureRef(int);
245 : char **ScanModuleReferences(const char * = "ATID");
246 :
247 4 : DDFModule *GetModule()
248 : {
249 4 : return &oDDFModule;
250 : }
251 : };
252 :
253 : /************************************************************************/
254 : /* SDTSRawLine */
255 : /************************************************************************/
256 :
257 : /** SDTS line feature, as read from LE* modules by SDTSLineReader. */
258 :
259 : class SDTSRawLine : public SDTSFeature
260 : {
261 : public:
262 : SDTSRawLine();
263 : virtual ~SDTSRawLine();
264 :
265 : int Read(SDTS_IREF *, DDFRecord *);
266 :
267 : /** Number of vertices in the padfX, padfY and padfZ arrays. */
268 : int nVertices;
269 :
270 : /** List of nVertices X coordinates. */
271 : double *padfX;
272 : /** List of nVertices Y coordinates. */
273 : double *padfY;
274 : /** List of nVertices Z coordinates - currently always zero. */
275 : double *padfZ;
276 :
277 : /** Identifier of polygon to left of this line. This is the SDTS PIDL
278 : subfield. */
279 : SDTSModId oLeftPoly;
280 :
281 : /** Identifier of polygon to right of this line. This is the SDTS PIDR
282 : subfield. */
283 : SDTSModId oRightPoly;
284 :
285 : /** Identifier for the start node of this line. This is the SDTS SNID
286 : subfield. */
287 : SDTSModId oStartNode; /* SNID */
288 :
289 : /** Identifier for the end node of this line. This is the SDTS ENID
290 : subfield. */
291 : SDTSModId oEndNode; /* ENID */
292 :
293 : void Dump(FILE *) override;
294 : };
295 :
296 : /************************************************************************/
297 : /* SDTSLineReader */
298 : /* */
299 : /* Class for reading any of the files lines. */
300 : /************************************************************************/
301 :
302 : /**
303 : Reader for SDTS line modules.
304 :
305 : Returns SDTSRawLine features. Normally readers are instantiated with
306 : the SDTSTransfer::GetIndexedReader() method.
307 :
308 : */
309 :
310 : class SDTSLineReader : public SDTSIndexedReader
311 : {
312 : SDTS_IREF *poIREF;
313 :
314 : public:
315 : explicit SDTSLineReader(SDTS_IREF *);
316 : ~SDTSLineReader();
317 :
318 : int Open(const char *);
319 : SDTSRawLine *GetNextLine();
320 : void Close();
321 :
322 57 : SDTSFeature *GetNextRawFeature() override
323 : {
324 57 : return GetNextLine();
325 : }
326 :
327 : void AttachToPolygons(SDTSTransfer *, int iPolyLayer);
328 : };
329 :
330 : /************************************************************************/
331 : /* SDTSAttrRecord */
332 : /************************************************************************/
333 :
334 : /**
335 : SDTS attribute record feature, as read from A* modules by
336 : SDTSAttrReader.
337 :
338 : Note that even though SDTSAttrRecord is derived from SDTSFeature, there
339 : are never any attribute records associated with attribute records using
340 : the aoATID[] mechanism. SDTSFeature::nAttributes will always be zero.
341 : */
342 :
343 : class SDTSAttrRecord : public SDTSFeature
344 : {
345 : public:
346 : SDTSAttrRecord();
347 : virtual ~SDTSAttrRecord();
348 :
349 : /** The entire DDFRecord read from the file. */
350 : DDFRecord *poWholeRecord;
351 :
352 : /** The ATTR DDFField with the user attribute. Each subfield is a
353 : attribute value. */
354 :
355 : DDFField *poATTR;
356 :
357 : virtual void Dump(FILE *) override;
358 : };
359 :
360 : /************************************************************************/
361 : /* SDTSAttrReader */
362 : /************************************************************************/
363 :
364 : /**
365 : Class for reading SDTSAttrRecord features from a primary or secondary
366 : attribute module.
367 : */
368 :
369 : class SDTSAttrReader : public SDTSIndexedReader
370 : {
371 : int bIsSecondary;
372 :
373 : public:
374 : SDTSAttrReader();
375 : virtual ~SDTSAttrReader();
376 :
377 : int Open(const char *);
378 : DDFField *GetNextRecord(SDTSModId * = nullptr, DDFRecord ** = nullptr,
379 : int bDuplicate = FALSE);
380 : SDTSAttrRecord *GetNextAttrRecord();
381 : void Close();
382 :
383 : /**
384 : Returns TRUE if this is a Attribute Secondary layer rather than
385 : an Attribute Primary layer.
386 : */
387 : int IsSecondary() const
388 : {
389 : return bIsSecondary;
390 : }
391 :
392 357 : SDTSFeature *GetNextRawFeature() override
393 : {
394 357 : return GetNextAttrRecord();
395 : }
396 : };
397 :
398 : /************************************************************************/
399 : /* SDTSRawPoint */
400 : /************************************************************************/
401 :
402 : /**
403 : Object containing a point feature (type NA, NO or NP).
404 : */
405 : class SDTSRawPoint : public SDTSFeature
406 : {
407 : public:
408 : SDTSRawPoint();
409 : virtual ~SDTSRawPoint();
410 :
411 : int Read(SDTS_IREF *, DDFRecord *);
412 :
413 : /** X coordinate of point. */
414 : double dfX;
415 : /** Y coordinate of point. */
416 : double dfY;
417 : /** Z coordinate of point. */
418 : double dfZ;
419 :
420 : /** Optional identifier of area marked by this point (i.e. PC01:27). */
421 : SDTSModId oAreaId; /* ARID */
422 :
423 : virtual void Dump(FILE *) override;
424 : };
425 :
426 : /************************************************************************/
427 : /* SDTSPointReader */
428 : /************************************************************************/
429 :
430 : /**
431 : Class for reading SDTSRawPoint features from a point module (type NA, NO
432 : or NP).
433 : */
434 :
435 : class SDTSPointReader : public SDTSIndexedReader
436 : {
437 : SDTS_IREF *poIREF;
438 :
439 : public:
440 : explicit SDTSPointReader(SDTS_IREF *);
441 : virtual ~SDTSPointReader();
442 :
443 : int Open(const char *);
444 : SDTSRawPoint *GetNextPoint();
445 : void Close();
446 :
447 132 : SDTSFeature *GetNextRawFeature() override
448 : {
449 132 : return GetNextPoint();
450 : }
451 : };
452 :
453 : /************************************************************************/
454 : /* SDTSRawPolygon */
455 : /************************************************************************/
456 :
457 : /**
458 : Class for holding information about a polygon feature.
459 :
460 : When directly read from a polygon module, the polygon has no concept
461 : of its geometry. Just its ID, and references to attribute records.
462 : However, if the SDTSLineReader::AttachToPolygons() method is called on
463 : the module containing the lines forming the polygon boundaries, then the
464 : nEdges/papoEdges information on the SDTSRawPolygon will be filled in.
465 :
466 : Once this is complete the AssembleRings() method can be used to fill in the
467 : nRings/nVertices/panRingStart/padfX/padfY/padfZ information defining the
468 : ring geometry.
469 :
470 : Note that the rings may not appear in any particular order, nor with any
471 : meaningful direction (clockwise or counterclockwise).
472 : */
473 :
474 : class SDTSRawPolygon : public SDTSFeature
475 : {
476 : void AddEdgeToRing(int, double *, double *, double *, int, int);
477 :
478 : public:
479 : SDTSRawPolygon();
480 : virtual ~SDTSRawPolygon();
481 :
482 : int Read(DDFRecord *);
483 :
484 : int nEdges;
485 : SDTSRawLine **papoEdges;
486 :
487 : void AddEdge(SDTSRawLine *);
488 :
489 : /** This method will assemble the edges associated with a polygon into
490 : rings, returning FALSE if problems are encountered during assembly. */
491 : int AssembleRings();
492 :
493 : /** Number of rings in assembled polygon. */
494 : int nRings;
495 : /** Total number of vertices in all rings of assembled polygon. */
496 : int nVertices;
497 : /** Offsets into padfX/padfY/padfZ for the beginning of each ring in the
498 : polygon. This array is nRings long. */
499 : int *panRingStart;
500 :
501 : /** List of nVertices X coordinates for the polygon (split over multiple
502 : rings via panRingStart. */
503 : double *padfX;
504 : /** List of nVertices Y coordinates for the polygon (split over multiple
505 : rings via panRingStart. */
506 : double *padfY;
507 : /** List of nVertices Z coordinates for the polygon (split over multiple
508 : rings via panRingStart. The values are almost always zero. */
509 : double *padfZ;
510 :
511 : virtual void Dump(FILE *) override;
512 : };
513 :
514 : /************************************************************************/
515 : /* SDTSPolygonReader */
516 : /************************************************************************/
517 :
518 : /** Class for reading SDTSRawPolygon features from a polygon (PC*) module. */
519 :
520 : class SDTSPolygonReader : public SDTSIndexedReader
521 : {
522 : int bRingsAssembled;
523 :
524 : public:
525 : SDTSPolygonReader();
526 : virtual ~SDTSPolygonReader();
527 :
528 : int Open(const char *);
529 : SDTSRawPolygon *GetNextPolygon();
530 : void Close();
531 :
532 36 : SDTSFeature *GetNextRawFeature() override
533 : {
534 36 : return GetNextPolygon();
535 : }
536 :
537 : void AssembleRings(SDTSTransfer *, int iPolyLayer);
538 : };
539 :
540 : /************************************************************************/
541 : /* SDTSRasterReader */
542 : /************************************************************************/
543 :
544 : /**
545 : Class for reading raster data from a raster layer.
546 :
547 : This class is somewhat unique among the reader classes in that it isn't
548 : derived from SDTSIndexedFeature, and it doesn't return "features". Instead
549 : it is used to read raster blocks, in the natural block size of the dataset.
550 : */
551 :
552 : class SDTSRasterReader
553 : {
554 : DDFModule oDDFModule;
555 :
556 : char szModule[20];
557 :
558 : int nXSize;
559 : int nYSize;
560 : int nXBlockSize;
561 : int nYBlockSize;
562 :
563 : int nXStart; /* SOCI */
564 : int nYStart; /* SORI */
565 :
566 : double adfTransform[6];
567 :
568 : public:
569 : char szINTR[4]; /* CE is center, TL is top left */
570 : char szFMT[32];
571 : char szUNITS[64];
572 : char szLabel[64];
573 :
574 : SDTSRasterReader();
575 : ~SDTSRasterReader();
576 :
577 : int Open(SDTS_CATD *poCATD, SDTS_IREF *, const char *pszModule);
578 : void Close();
579 :
580 : int GetRasterType(); /* 1 = int16, see GDAL types */
581 : #define SDTS_RT_INT16 1
582 : #define SDTS_RT_FLOAT32 6
583 :
584 : int GetTransform(double *);
585 :
586 : int GetMinMax(double *pdfMin, double *pdfMax, double dfNoData);
587 :
588 : /**
589 : Fetch the raster width.
590 :
591 : @return the width in pixels.
592 : */
593 2 : int GetXSize() const
594 : {
595 2 : return nXSize;
596 : }
597 :
598 : /**
599 : Fetch the raster height.
600 :
601 : @return the height in pixels.
602 : */
603 2 : int GetYSize() const
604 : {
605 2 : return nYSize;
606 : }
607 :
608 : /** Fetch the width of a source block (usually same as raster width). */
609 2 : int GetBlockXSize() const
610 : {
611 2 : return nXBlockSize;
612 : }
613 :
614 : /** Fetch the height of a source block (usually one). */
615 2 : int GetBlockYSize() const
616 : {
617 2 : return nYBlockSize;
618 : }
619 :
620 : int GetBlock(int nXOffset, int nYOffset, void *pData);
621 : };
622 :
623 : /************************************************************************/
624 : /* SDTSTransfer */
625 : /************************************************************************/
626 :
627 : /**
628 : Master class representing an entire SDTS transfer.
629 :
630 : This class is used to open the transfer, to get a list of available
631 : feature layers, and to instantiate readers for those layers.
632 :
633 : */
634 :
635 : class SDTSTransfer
636 : {
637 : public:
638 : SDTSTransfer();
639 : ~SDTSTransfer();
640 :
641 : int Open(const char *);
642 : void Close();
643 :
644 : int FindLayer(const char *);
645 :
646 20 : int GetLayerCount() const
647 : {
648 20 : return nLayers;
649 : }
650 :
651 : SDTSLayerType GetLayerType(int) const;
652 : int GetLayerCATDEntry(int) const;
653 :
654 : SDTSLineReader *GetLayerLineReader(int);
655 : SDTSPointReader *GetLayerPointReader(int);
656 : SDTSPolygonReader *GetLayerPolygonReader(int);
657 : SDTSAttrReader *GetLayerAttrReader(int);
658 : SDTSRasterReader *GetLayerRasterReader(int);
659 : DDFModule *GetLayerModuleReader(int);
660 :
661 : SDTSIndexedReader *GetLayerIndexedReader(int);
662 :
663 : /**
664 : Fetch the catalog object for this transfer.
665 :
666 : @return pointer to the internally managed SDTS_CATD for the transfer.
667 : */
668 13 : SDTS_CATD *GetCATD()
669 : {
670 13 : return &oCATD;
671 : }
672 :
673 : SDTS_IREF *GetIREF()
674 : {
675 : return &oIREF;
676 : }
677 :
678 : /**
679 : Fetch the external reference object for this transfer.
680 :
681 : @return pointer to the internally managed SDTS_XREF for the transfer.
682 : */
683 3 : SDTS_XREF *GetXREF()
684 : {
685 3 : return &oXREF;
686 : }
687 :
688 : SDTSFeature *GetIndexedFeatureRef(SDTSModId *,
689 : SDTSLayerType *peType = nullptr);
690 :
691 : DDFField *GetAttr(SDTSModId *);
692 :
693 : int GetBounds(double *pdfMinX, double *pdfMinY, double *pdfMaxX,
694 : double *pdfMaxY);
695 :
696 : private:
697 : SDTS_CATD oCATD;
698 : SDTS_IREF oIREF;
699 : SDTS_XREF oXREF;
700 :
701 : int nLayers;
702 : int *panLayerCATDEntry;
703 : SDTSIndexedReader **papoLayerReader;
704 : };
705 :
706 : #endif /* ifndef SDTS_AL_H_INCLUDED */
|
