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