dtedCell.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1998 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: dtedCell.h,v $ $Revision: 1.11 $ $State: Exp $
*********************************************************************/
#ifndef dtedCell_H_
#define dtedCell_H_

#include "dted/dtedDefines.h"
#include "geometry/point.h"

// Forward declarations
class DtDtedReader;
class DtGroup;
class DtTriangleIndirect;
class DtGdbNode;
class DtUtmReferencePoint;

struct DtUhlRecord
{
public:
   char Id[3];
   char Reserved1[1];
   char LonOrigin[8];
   char LatOrigin[8];
   char LonDataInterval[4];
   char LatDataInterval[4];
   char AbsVerticalAcc[4];
   char SecurityCode[3];
   char UniqueRef[12];
   char NumLonLines[4];
   char NumLatLines[4];
   char MultAcc[1];
   char Reserved2[24];
};


struct DtDsiRecord
{
public:
   char Id[3];
   char SecurityCode[1];
   char SecurityControl[2];
   char SecurityHandling[27];
   char Reserved1[26];
   char DMASeries[5];
   char UniqueRef[15];
   char Reserved2[8];
   char DataEditionNumber[2];
   char MatchMergeVersion[1];
   char MaintenanceDate[4];
   char MatchMergeDate[4];
   char MaintenanceDesc[4];
   char ProducerCode[8];
   char Reserved3[16];
   char ProductSpecification[9];
   char ProductSpecificationAmendment[2];
   char ProductSpecificationDate[4];
   char VerticalDatum[3];
   char HorizontalDatum[5];
   char FreeText[10];
   char CompilationDate[4];
   char Reserved4[22];
   char LatDataOrigin[9];
   char LonDataOrigin[10];
   char LatSWCorner[7];
   char LonSWCorner[8];
   char LatNWCorner[7];
   char LonNWCorner[8];
   char LatNECorner[7];
   char LonNECorner[8];
   char LatSECorner[7];
   char LonSECorner[8];
   char ClockWiseOrientation[9];
   char LatInterval[4];
   char LonInterval[4];
   char NumLatLines[4];
   char NumLonLines[4];
   char PartialCellIndicator[2];
   char Reserved5[101];
   char Reserved6[100];
   char Reserved7[156];
};


struct DtAccRecord
{
public:
   char Id[3];
   char AbsHorzAcc[4];
   char AbsVertAcc[4];
   char RelHorzAcc[4];
   char RelVertAcc[4];
   char Reserved1[36];
   char MultipleAccOutline[2];
   char Reserved2[2643]; // ???
};


struct DtDmaDataRecord
{
public:
   char Id[1];
   char BlockCount[3];
   char LonCount[2];
   char LatCount[2];
};


class DT_DLL_dted DtMapData
{
public:
   short **myElevationGrid;
};


class DT_DLL_dted DtDtedCellData
{
public:
   double SELat;
   double SELon;
   double SWLat;
   double SWLon;
   double NELat;
   double NELon;
   double NWLat;
   double NWLon;
   double CenterLat;
   double CenterLon;

   double LatInterval;
   double LonInterval;

   long NumLatPoints;
   long NumLonPoints;
   long NumPoints;

   short MinElevation;
   short MaxElevation;

   char Series[6];

   short AbsHorzAcc;
   short AbsVertAcc;
   short RelHorzAcc;
   short RelVertAcc;
};


//
// Instances of DtDtedCell are individual dted files loaded into memory.
class DT_DLL_dted DtDtedCell
{
public:
   // constructor
   DtDtedCell();

   // destructor
   virtual ~DtDtedCell();

   // Read the Defense Mapping Agency (DMA) terrain elevation file and build
   // the data structures for a DtDtedCell file. Convert data to DtDtedCell 
   // form where necessary. Allocate memory appropriately, and free local 
   // structures upon completion.
   virtual bool readDma(const char* DMAFile);

   // the following builds a triangle-based node and returns it.  It is the 
   // responsibility of the receiver to delete the returned object.
   virtual DtGdbNode* utmTriNode(const int postSpacing, double lowColorHeight,
      double highColorHeight, bool reliefShading, double minLatitude,
      double maxLatitude, double minLongitude, double maxLongitude, DtDtedReader* reader);

   // the following builds a geodetic triangle-based node and returns it.  
   // It is the responsibility of the receiver to delete the returned object.
   virtual DtGdbNode* geoTriNode(int postSpacing, double lowColorHeight,
      double highColorHeight, bool reliefShading, double minLatitude,
      double maxLatitude, double minLongitude, double maxLongitude, DtDtedReader* reader);

   // the following builds a flat earth triangle-based node and returns it.  
   // It is the responsibility of the receiver to delete the returned object.
   virtual DtGdbNode* flatEarthTriNode(int postSpacing, double lowColorHeight, 
      double highColorHeight, bool reliefShading, double minLatitude, 
      double maxLatitude, double minLongitude, double maxLongitude, DtDtedReader* reader);

   // get the south west latitude and longitude in degrees
   virtual double swLat();
   virtual double swLon();

protected:
   // copy constructor
   DtDtedCell(const DtDtedCell& orig);

   // assignment operator
   DtDtedCell& operator=(const DtDtedCell& orig);

   // Extract the DMA Accuracy figure from the ascii data which is in
   // the DMA raw data.
   virtual short cvDmaAccuracy(char DMAAccuracy[]);

   // Extract the DMA Interval figure from the ascii data which is in
   // the DMA raw data.
   virtual float cvDmaInterval(char DMAInterval[]);

   // Extract the DMA Latitude figure from the ascii data which is in
   // the DMA raw data.
   virtual float cvDmaLat(char DMALat[]);

   // Extract the DMA Longitude figure from the ascii data which is in
   // the DMA raw data.
   virtual float cvDmaLon(char DMALon[]);

   // allocate the lowest-level groups and fill each with two triangles
   virtual bool fillGroupsWithTris(DtGroup**& groups, int gridWidth, 
      int gridHeight, double lowColorHeight, double highColorHeight, 
      bool reliefShading, int vertexIDOffset, DtDtedReader* reader);

   // The following fills the reader's terrainDb's vertex manager with 
   // vertices in UTM coordinates based on the incoming dimensions and
   // post spacing.  It also calculates and returns the gridWidth
   // and gridHeight.
   virtual bool buildUTMVertexManager(int& gridWidth, 
      int& gridHeight, int postSpacing, double minLatitude,
      double maxLatitude, double minLongitude, double maxLongitude,
      DtDtedReader* reader);

   // The following fills the reader's terrainDb's vertex manager with 
   // vertices in Geodetic coordinates based on the incoming dimensions 
   // and post spacing.  It also calculates and returns the gridWidth
   // and gridHeight.
   virtual bool buildGeodeticVertexManager(int& gridWidth, 
      int& gridHeight, int postSpacing, double minLatitude,
      double maxLatitude, double minLongitude, double maxLongitude,
      DtDtedReader* reader);

   // The following fills the reader's terrainDb's vertex manager with 
   // vertices in Geodetic coordinates based on the incoming dimensions 
   // and post spacing.  It also calculates and returns the gridWidth
   // and gridHeight.
   virtual bool buildFlatEarthVertexManager(int& gridWidth, 
      int& gridHeight, int postSpacing, double minLatitude,
      double maxLatitude, double minLongitude, double maxLongitude,
      DtDtedReader* reader);

   // Set the surface for the triangle as a function of vertex heights
   virtual bool setTriangleSurface(DtTriangleIndirect* tri, 
      unsigned int numSurfaces, double lowColorHeight, double highColorHeight,
      bool releifShading);

   // builds a balanced tree.  topGroup is the parent; groups is an array
   // of pointers to all the low-level groups; numLonGroups is the total
   // number of groups running west to east; numLatGroups is the total 
   // number of groups running south to north; westLonGroup is the west-most
   // group number; eastLonGroup is the east-most group number; southLatGroup
   // is the south-most group number; and northLatGroup is the north-most
   // group number.
   virtual void balance(DtGroup* topGroup, DtGroup** groups,
      unsigned int numLatGroups, unsigned int westLonGroup,
      unsigned int eastLonGroup, unsigned int southLatGroup,
      unsigned int northLatGroup, DtDtedReader* reader);
  
protected:
   DtDtedCellData myHeader;
   DtMapData* myMapData;

   int myGridpostListWidth;
   int myGridpostListHeight;

   // The minimum size (along both the width and height dimension) of
   // a grid patch.
   static const int theGridPatchSizeThreshold;
};

#endif