include/shape/shapefile.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: shapefile.h,v $ $Revision: 1.21 $ $State: Exp $
*******************************************************************************/

#ifndef shapefile_H_
#define shapefile_H_

#include "shape/shapeDefines.h"
#include <vlutil/vlFilename.h>
#include <vlutil/vlNetTypes.h>
#include <vlutil/vlList.h>
#include <vlutil/vlHashlist.h>
#include "shape/shapeProjectionInformation.h"

class DtShapeEntry;
class DtShapeHeader;
class DtShapeReader;
class DtShapeVectorReader;
class DtShapeVectorReader;
class DtShapeInitializer;
class DtShapeVectorInitializer;
class DtGroup;
class DtGeodeticCoord;

class DtVectorNetwork;

typedef void (*DtRealShapeImportFcn)(const char* feature, DtReal& value);
typedef void (*DtIntegerShapeImportFcn)(const char* feature, int& value);
typedef void (*DtStringShapeImportFcn)(const char* feature, DtString& value);

//
// DtShapefile is the base class for DtShapeFeatureFile and DtShapeTerrainFile.
// It provides the interface for reading shape files, and the capability to 
// read the associated .dbf dBASE files.
//
class DT_DLL_shape DtShapefile
{

public:

   // Constructor
   DtShapefile(const DtShapeInitializer* i);

   // Constructor
   DtShapefile(const DtShapeVectorInitializer* i);

   // Destructor
   virtual ~DtShapefile();

private:
   // Copy constructor and Assignment operator not implemented
   DtShapefile(const DtShapefile& original);
   DtShapefile& operator=(const DtShapefile& original);

public:

   // Registers default dBASE import functions. Override this function to
   // change or add import functions.
   virtual void init();
   
   // Opens the given file and adds each DtShapeRecord to myList
   virtual bool load(const DtFilename& path, const DtShapeEntry* entry);

   // Overridden by subclasses to process the DtShapeReader
   virtual DtGroup* import(DtShapeReader* db) = 0;

   // Overridden by subclasses to process the DtShapeVectorReader
   virtual bool importFeatures(DtShapeVectorReader* db) = 0;
   
   // Returns myHeader->myBoundingBox[0]
   virtual double xMin();
   // Returns myHeader->myBoundingBox[1];
   virtual double yMin();
   // Returns myHeader->myBoundingBox[2];
   virtual double xMax();
   // Returns myHeader->myBoundingBox[3];
   virtual double yMax();

   // Returns myList
   virtual DtList &list();


   //
   // dBASE import functions
   //
   
   // Associates the given dBASE type with a DtRealShapeImportFcn that can 
   // convert it to a DtReal.
   virtual void setRealImportFunction(const char type, DtRealShapeImportFcn fcn);
   // Finds the DtRealShapeImportFcn associated with the give dBASE type
   virtual DtRealShapeImportFcn lookupRealImportFunction(const char type);
   // Converts the feature (as returned from readFeature) to a DtReal value
   static void importNumberAsReal(const char* feature, DtReal& value);

   // Associates the given dBASE type with a DtIntegerShapeImportFcn that can 
   // convert it to a int.
   virtual void setIntegerImportFunction(const char type, DtIntegerShapeImportFcn fcn);
   // Finds the DtIntegerShapeImportFcn associated with the give dBASE type
   virtual DtIntegerShapeImportFcn lookupIntegerImportFunction(const char type);
   // Converts the feature (as returned from readFeature) to an int value
   static void importNumberAsInteger(const char* feature, int& value);

   // Associates the given dBASE type with a DtStringShapeImportFcn that can 
   // convert it to a DtString.
   virtual void setStringImportFunction(const char type, DtStringShapeImportFcn fcn);
   // Finds the DtStringShapeImportFcn associated with the give dBASE type
   virtual DtStringShapeImportFcn lookupStringImportFunction(const char type);
   // Converts the feature (as returned from readFeature) to a DtString value
   static void importCharAsString(const char* feature, DtString& value);

   virtual DtString projectionType() const;

   DtShapeProjection* projectionInformation() const;

   static void setShapeProjectionCreatorFcn(DtShapeProjectionCreatorFcn);

   // Returns a coordinate system from the shape projection (if exists).  NULL if not.
   // Caller must free returned pointer
   virtual Coordinate_System* coordinateSystem() const;

   // Gets lower left/upper right corners in geodetic
   virtual void getCorners(DtGeodeticCoord& ll, DtGeodeticCoord& ur);

   // @name Open/close dBASE file functions
   // @{
   // Opens and closes the .dbf dBASE file associated with the shape file, 
   // initializing the myDbfFile pointer. 
   // The ESRI shape standard requires them to have the same name prefix. 
   // The caller is responsible for closing the myDbfFile pointer.
   virtual bool openDbf();

   // Given shapefile and path, opens .dbf file associated with it
   virtual bool openDbf(const DtFilename&);

   virtual bool closeDbf();
   // @}

   // @name Column dBASE file functions
   // @{
   // Returns information about columns

   // Returns number of columns in dbf file
   virtual int numDbfColumns() const;
   virtual bool column(int col, DtString& colName, char& colType, unsigned char& colLength);
   // @}

   // Tries to load and parse .prj file based on current shape file to get projection information.  Builds
   // a hash list (key/value pair) of all information found
   virtual void loadProjectionFile();

protected:

   // Locates the record with the given featureName and featureNumber, allocates
   // a string for the data, and returns the dBASE type ('C', 'N', etc.) in
   // fieldType. The caller is responsible for freeing the returned pointer!
   virtual char* readFeature(const DtString& featureName, int featureNumber,
      char& fieldType);

   // Calls readFeature with the given featureName and featureNumber, then
   // sets the value using the import function returned from 
   // lookupRealImportFunction
   virtual bool readFeatureAsReal(const DtString& featureName, int featureNumber, DtReal& value);

   // Calls readFeature with the given featureName and featureNumber, then
   // sets the value using the import function returned from 
   // lookupIntegerImportFunction
   virtual bool readFeatureAsInteger(const DtString& featureName, int featureNumber, int& value);

   // Calls readFeature with the given featureName and featureNumber, then
   // sets the value using the import function returned from 
   // lookupStringImportFunction
   virtual bool readFeatureAsString(const DtString& featureName, 
      int featureNumber, DtString& value);

protected:

   const DtShapeInitializer*       myInitializer;
   const DtShapeVectorInitializer* myVectorInitializer;

   const DtShapeEntry*      myEntry;
   DtFilename               myFilename;
   DtShapeHeader*           myHeader;
   DtList                   myList;
   DtShapeReader*           myReader;
   DtShapeVectorReader*     myVectorReader;

   // .dbf file -- should be opened only for the duration of the import!
   FILE* myDbfFile;
   DtNetInt32  myDbfRecordCount;
   DtNetInt16  myDbfRecordSize;
   DtNetInt16  myDbfHeaderSize;

   DtHashlist myRealImportFunctions;
   DtHashlist myIntegerImportFunctions;
   DtHashlist myStringImportFunctions;

   // Contains the projection type (string) that should be used to convert points
   // from a non-geodetic source to a geodetic (degree) source
   DtShapeProjection* myProjectionInformation;

   static DtShapeProjectionCreatorFcn  theShapeProjectionCreator;
};

inline DtShapeProjection* DtShapefile::projectionInformation() const
{
   return myProjectionInformation;
}

#endif