sdts_al.h

/******************************************************************************
 * $Id$
 *
 * Project:  SDTS Translator
 * Purpose:  Include file for entire SDTS Abstraction Layer functions.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999, Frank Warmerdam
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/
 
#ifndef SDTS_AL_H_INCLUDED
#define SDTS_AL_H_INCLUDED
 
#include "cpl_conv.h"
#include "iso8211.h"
 
class SDTS_IREF;
class SDTSModId;
class SDTSTransfer;
 
#define SDTS_SIZEOF_SADR        8
 
char **SDTSScanModuleReferences( DDFModule *, const char * );
 
/************************************************************************/
/*                              SDTS_IREF                               */
/************************************************************************/
 
class SDTS_IREF
{
    int         nDefaultSADRFormat;
 
  public:
                SDTS_IREF();
                ~SDTS_IREF();
 
    int         Read( const char *pszFilename );
 
    char        *pszXAxisName;                  /* XLBL */
    char        *pszYAxisName;                  /* YLBL */
 
    double      dfXScale;                       /* SFAX */
    double      dfYScale;                       /* SFAY */
 
    double      dfXOffset;                      /* XORG */
    double      dfYOffset;                      /* YORG */
 
    double      dfXRes;                         /* XHRS */
    double      dfYRes;                         /* YHRS */
 
    char        *pszCoordinateFormat;           /* HFMT */
 
    int         GetSADRCount( DDFField * ) const;
    int         GetSADR( DDFField *, int, double *, double *, double * );
};
 
/************************************************************************/
/*                              SDTS_XREF                               */
/************************************************************************/
 
class SDTS_XREF
{
  public:
                SDTS_XREF();
                ~SDTS_XREF();
 
    int         Read( const char *pszFilename );
 
    char        *pszSystemName;
 
    char        *pszDatum;
 
    int         nZone;
};
 
/************************************************************************/
/*                              SDTS_CATD                               */
/************************************************************************/
class SDTS_CATDEntry;
 
typedef enum {
  SLTUnknown,
  SLTPoint,
  SLTLine,
  SLTAttr,
  SLTPoly,
  SLTRaster
} SDTSLayerType;
 
class SDTS_CATD
{
    char        *pszPrefixPath;
 
    int         nEntries;
    SDTS_CATDEntry **papoEntries;
 
  public:
                SDTS_CATD();
                ~SDTS_CATD();
 
    int         Read( const char * pszFilename );
 
    const char  *GetModuleFilePath( const char * pszModule ) const;
 
    int         GetEntryCount() const { return nEntries; }
    const char * GetEntryModule(int) const;
    const char * GetEntryTypeDesc(int) const;
    const char * GetEntryFilePath(int) const;
    SDTSLayerType GetEntryType(int) const;
};
 
/************************************************************************/
/*                              SDTSModId                               */
/************************************************************************/
 
class SDTSModId
{
  public:
                SDTSModId() { szModule[0] = '\0';
                              nRecord = -1;
                              szOBRP[0] = '\0';
                              szName[0] = '\0'; }
 
    int         Set( DDFField * );
 
    const char *GetName();
 
    char        szModule[8];
 
    int         nRecord;
 
    char        szOBRP[8];
 
    char        szName[20];
};
 
/************************************************************************/
/*                             SDTSFeature                              */
/************************************************************************/
 
class SDTSFeature
{
public:
 
                        SDTSFeature();
    virtual            ~SDTSFeature();
 
    SDTSModId           oModId;
 
    int         nAttributes;
 
    SDTSModId   *paoATID;
 
    void        ApplyATID( DDFField * );
 
    virtual void Dump( FILE * ) = 0;
};
 
/************************************************************************/
/*                          SDTSIndexedReader                           */
/************************************************************************/
 
class SDTSIndexedReader
{
    int                 nIndexSize;
    SDTSFeature       **papoFeatures;
 
    int                 iCurrentFeature;
 
protected:
    DDFModule           oDDFModule;
 
public:
                        SDTSIndexedReader();
    virtual            ~SDTSIndexedReader();
 
    virtual SDTSFeature  *GetNextRawFeature() = 0;
 
    SDTSFeature        *GetNextFeature();
 
    virtual void        Rewind();
 
    void                FillIndex();
    void                ClearIndex();
    int                 IsIndexed() const;
 
    SDTSFeature        *GetIndexedFeatureRef( int );
    char **             ScanModuleReferences( const char * = "ATID" );
 
    DDFModule          *GetModule() { return &oDDFModule; }
};
 
/************************************************************************/
/*                             SDTSRawLine                              */
/************************************************************************/
 
class SDTSRawLine : public SDTSFeature
{
  public:
                SDTSRawLine();
    virtual    ~SDTSRawLine();
 
    int         Read( SDTS_IREF *, DDFRecord * );
 
    int         nVertices;
 
    double      *padfX;
    double      *padfY;
    double      *padfZ;
 
    SDTSModId   oLeftPoly;
 
    SDTSModId   oRightPoly;
 
    SDTSModId   oStartNode;             /* SNID */
 
    SDTSModId   oEndNode;               /* ENID */
 
    void        Dump( FILE * ) override;
};
 
/************************************************************************/
/*                            SDTSLineReader                            */
/*                                                                      */
/*      Class for reading any of the files lines.                       */
/************************************************************************/
 
class SDTSLineReader : public SDTSIndexedReader
{
    SDTS_IREF   *poIREF;
 
  public:
                explicit SDTSLineReader( SDTS_IREF * );
                ~SDTSLineReader();
 
    int         Open( const char * );
    SDTSRawLine *GetNextLine();
    void        Close();
 
    SDTSFeature *GetNextRawFeature() override { return GetNextLine(); }
 
    void        AttachToPolygons( SDTSTransfer *, int iPolyLayer  );
};
 
/************************************************************************/
/*                            SDTSAttrRecord                            */
/************************************************************************/
 
class SDTSAttrRecord : public SDTSFeature
{
  public:
                SDTSAttrRecord();
    virtual    ~SDTSAttrRecord();
 
    DDFRecord   *poWholeRecord;
 
    DDFField    *poATTR;
 
    virtual void Dump( FILE * ) override;
};
 
/************************************************************************/
/*                            SDTSAttrReader                            */
/************************************************************************/
 
class SDTSAttrReader : public SDTSIndexedReader
{
    int         bIsSecondary;
 
  public:
                SDTSAttrReader();
   virtual     ~SDTSAttrReader();
 
    int         Open( const char * );
    DDFField    *GetNextRecord( SDTSModId * = nullptr,
                                DDFRecord ** = nullptr,
                                int bDuplicate = FALSE );
    SDTSAttrRecord *GetNextAttrRecord();
    void        Close();
 
    int         IsSecondary() const { return bIsSecondary; }
 
    SDTSFeature *GetNextRawFeature() override { return GetNextAttrRecord(); }
};
 
/************************************************************************/
/*                             SDTSRawPoint                             */
/************************************************************************/
 
class SDTSRawPoint : public SDTSFeature
{
  public:
                SDTSRawPoint();
    virtual    ~SDTSRawPoint();
 
    int         Read( SDTS_IREF *, DDFRecord * );
 
    double      dfX;
    double      dfY;
    double      dfZ;
 
    SDTSModId   oAreaId;                /* ARID */
 
    virtual void Dump( FILE * ) override;
};
 
/************************************************************************/
/*                           SDTSPointReader                            */
/************************************************************************/
 
class SDTSPointReader : public SDTSIndexedReader
{
    SDTS_IREF   *poIREF;
 
  public:
                explicit SDTSPointReader( SDTS_IREF * );
    virtual    ~SDTSPointReader();
 
    int         Open( const char * );
    SDTSRawPoint *GetNextPoint();
    void        Close();
 
    SDTSFeature *GetNextRawFeature() override { return GetNextPoint(); }
};
 
/************************************************************************/
/*                             SDTSRawPolygon                           */
/************************************************************************/
 
class SDTSRawPolygon : public SDTSFeature
{
    void        AddEdgeToRing( int, double *, double *, double *, int, int );
 
  public:
                SDTSRawPolygon();
    virtual    ~SDTSRawPolygon();
 
    int         Read( DDFRecord * );
 
    int         nEdges;
    SDTSRawLine **papoEdges;
 
    void        AddEdge( SDTSRawLine * );
 
    int         AssembleRings();
 
    int         nRings;
    int         nVertices;
    int         *panRingStart;
 
    double      *padfX;
    double      *padfY;
    double      *padfZ;
 
    virtual void Dump( FILE * ) override;
};
 
/************************************************************************/
/*                          SDTSPolygonReader                           */
/************************************************************************/
 
class SDTSPolygonReader : public SDTSIndexedReader
{
    int         bRingsAssembled;
 
  public:
                SDTSPolygonReader();
    virtual    ~SDTSPolygonReader();
 
    int         Open( const char * );
    SDTSRawPolygon *GetNextPolygon();
    void        Close();
 
    SDTSFeature *GetNextRawFeature() override { return GetNextPolygon(); }
 
    void        AssembleRings( SDTSTransfer *, int iPolyLayer );
};
 
/************************************************************************/
/*                           SDTSRasterReader                           */
/************************************************************************/
 
class SDTSRasterReader
{
    DDFModule   oDDFModule;
 
    char        szModule[20];
 
    int         nXSize;
    int         nYSize;
    int         nXBlockSize;
    int         nYBlockSize;
 
    int         nXStart;                /* SOCI */
    int         nYStart;                /* SORI */
 
    double      adfTransform[6];
 
  public:
    char        szINTR[4];              /* CE is center, TL is top left */
    char        szFMT[32];
    char        szUNITS[64];
    char        szLabel[64];
 
                SDTSRasterReader();
                ~SDTSRasterReader();
 
    int         Open( SDTS_CATD * poCATD, SDTS_IREF *,
                      const char * pszModule  );
    void        Close();
 
    int         GetRasterType();        /* 1 = int16, see GDAL types */
#define SDTS_RT_INT16   1
#define SDTS_RT_FLOAT32 6
 
    int         GetTransform( double * );
 
    int         GetMinMax( double * pdfMin, double * pdfMax,
                           double dfNoData );
 
    int         GetXSize() const { return nXSize; }
    int         GetYSize() const { return nYSize; }
 
    int         GetBlockXSize() const { return nXBlockSize; }
    int         GetBlockYSize() const { return nYBlockSize; }
 
    int         GetBlock( int nXOffset, int nYOffset, void * pData );
};
 
/************************************************************************/
/*                             SDTSTransfer                             */
/************************************************************************/
 
class SDTSTransfer
{
  public:
                SDTSTransfer();
                ~SDTSTransfer();
 
    int         Open( const char * );
    void        Close();
 
    int         FindLayer( const char * );
    int         GetLayerCount() const { return nLayers; }
    SDTSLayerType GetLayerType( int ) const;
    int         GetLayerCATDEntry( int ) const;
 
    SDTSLineReader *GetLayerLineReader( int );
    SDTSPointReader *GetLayerPointReader( int );
    SDTSPolygonReader *GetLayerPolygonReader( int );
    SDTSAttrReader *GetLayerAttrReader( int );
    SDTSRasterReader *GetLayerRasterReader( int );
    DDFModule   *GetLayerModuleReader( int );
 
    SDTSIndexedReader *GetLayerIndexedReader( int );
 
    SDTS_CATD   *GetCATD() { return &oCATD ; }
 
    SDTS_IREF   *GetIREF() { return &oIREF; }
 
    SDTS_XREF   *GetXREF() { return &oXREF; }
 
    SDTSFeature *GetIndexedFeatureRef( SDTSModId *,
                                       SDTSLayerType *peType = nullptr);
 
    DDFField *GetAttr( SDTSModId * );
 
    int          GetBounds( double *pdfMinX, double *pdfMinY,
                            double *pdfMaxX, double *pdfMaxY );
 
  private:
 
    SDTS_CATD   oCATD;
    SDTS_IREF   oIREF;
    SDTS_XREF   oXREF;
 
    int         nLayers;
    int         *panLayerCATDEntry;
    SDTSIndexedReader **papoLayerReader;
};
 
#endif /* ifndef SDTS_AL_H_INCLUDED */