include/ctdb/c4b.h

Go to the documentation of this file.

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

#ifndef c4b_H
#define c4b_H

#include "ctdb/ctdbDefines.h"
#include <vlutil/vlNetTypes.h>

#include <vlutil/vlPrint.h>

#include "geometry/point.h"
#include "gdb/gdbNode.h"
#include "gdb/group.h"
#include "gdb/feature.h"
#include "gdb/gridPstLst.h"
#include "gdb/surfMgr.h"
#include "geometry/surface.h"
#include "gdb/terrainReader.h"

#include "gdb/terrainDb.h"

#define DO_CANOPIES
#define DO_TREES
#define DO_TREELINES
#define DO_LINEAR_FEATURES
#define DO_BUILDINGS
#define DO_GRID_POSTS
#define DO_TINS
#define DO_MICRO_TERRAIN


static const int CTDB_N_SOILS = 16;

static const int DATUM_ED50             = 0;
static const int DATUM_ED79             = 1;
static const int DATUM_WGS72            = 2;
static const int DATUM_WGS84            = 3;
static const int DATUM_CONUSNAD27       = 4;
static const int DATUM_NASBNAD27        = 5;
static const int DATUM_NASANAD27        = 6;
static const int DATUM_NAD83            = 7;
static const int DATUM_ADINDAN          = 8;
static const int DATUM_ARC50            = 9;
static const int DATUM_AUSTRALIAN       = 10;
static const int DATUM_BUKITRIMPAH      = 11;
static const int DATUM_CAMPAREAASTRO    = 12;
static const int DATUM_DJAKARTA         = 13;
static const int DATUM_GEOD49           = 14;
static const int DATUM_GUAM63           = 15;
static const int DATUM_GUNUNGSEGARA     = 16;
static const int DATUM_HERATNORTH       = 17;
static const int DATUM_HJORSEY55        = 18;
static const int DATUM_INDIAN           = 19;
static const int DATUM_IRELAND65        = 20;
static const int DATUM_KERTAU48         = 21;
static const int DATUM_LIBERIA64        = 22;
static const int DATUM_LUZON            = 23;
static const int DATUM_MERCHICH         = 24;
static const int DATUM_NIGERIA          = 25;
static const int DATUM_ALASKACANADA27   = 26;
static const int DATUM_MAUI             = 27;
static const int DATUM_OAHU             = 28;
static const int DATUM_KAUAI            = 29;
static const int DATUM_GREATBRITAIN36   = 30;
static const int DATUM_QORNOQ           = 31;
static const int DATUM_SACAMPOINCHAUSPE = 32;
static const int DATUM_SACHUAASTRO      = 33;
static const int DATUM_SACORREGOALEGRE  = 34;
static const int DATUM_SAPROVISIONAL56  = 35;
static const int DATUM_SAYACARE         = 36;
static const int DATUM_TAMANARIVEOBSV25 = 37;
static const int DATUM_TIMBOLAI48       = 38;
static const int DATUM_TOKYO            = 39;

static const int CTDB_PATCH_CACHES = 16;
static const int CTDB_NAME_LENGTH = 14;
static const int CTDB_DATE_LENGTH = 28;
static const int CTDB_HEADER_RESERVED = 10;

class DtC4bReader;

DT_DLL_ctdb double scale_to_patch(double bar);  

/*
 * Class definitions.
 */

class DT_DLL_ctdb c4b_file_header_format
{
  public:

    bool is_curved();
    bool is_sw_ne();
    bool is_gridded();
    bool is_tinned();
    void describe();

  private:

    DtNetU32   raw_bits;
};
    

/*
 * These values were determined from a combination of s1000 and modsaf rdr files.
 */

typedef enum
{
  C4B_SOIL_NON_C4B_SOIL = 0,  // Unknown type of soil 
  C4B_SOIL_ROAD = 1,    // Asphalt or other hard surface     
  C4B_SOIL_RCI250 = 2,     // Packed soil or dirt road          
  C4B_SOIL_RCI050 = 3,     // Soft sandy soil                   
  C4B_SOIL_DEEP_WATER = 4, // Impassable deep water             
  C4B_SOIL_SHALLOW_WATER = 5, // Passable shallow water            
  C4B_SOIL_MUD = 6,     // Muddy soil                        
  C4B_SOIL_MUDDY_ROAD = 7, // Wet dirt road                     
  C4B_SOIL_ICE = 8,     // Slick ice surface                 
  C4B_SOIL_SWAMP = 9,      // Very soft surface                 
  C4B_SOIL_FORRESTED = 10, // Canopy or forrested area          
  C4B_SOIL_US_RAILROAD = 11,  // Railroad w/ US specifications     
  C4B_SOIL_EURO_RAILROAD = 12,   // Railroad w/ European specs.       
  C4B_SOIL_ROCKY = 13,     // Small rocks <= 18 inches          
  C4B_SOIL_BOULDERS = 14,  // Large boulders 6 ft. high         

  // Weird, eh?  (What a kludge.) 

  C4B_SOIL_FLIMSY = 15,    // Indoor surface for DI             
  C4B_SOIL_NO_GO = 15      // General No Go Terrain for NTC     

} c4b_s1000_soil_type;




class DT_DLL_ctdb c4b_soil_map_entry
{
  public:

    bool    is_water();
    bool    is_no_go();
    bool    is_slow_go();
    bool    is_road();
    unsigned int     CCTT_constant();
    c4b_s1000_soil_type SIMNET_constant();
    void    describe();

  private:

    DtNetU32   raw_bits;
};


class DT_DLL_ctdb c4b_file_header
{
  public:
    bool       read(FILE *fp);
    void       describe();

    DtNetInt32       format;
    c4b_file_header_format db_format;
    DtNetFloat64     fixed_point_basis;
    c4b_soil_map_entry     soil_map[CTDB_N_SOILS];
    DtNetInt32       post_increment;
    DtNetInt32       posts_per_patch_side;
    DtNetInt32       pages_wide;
    DtNetInt32       pages_high;
    DtNetInt32       min_x;
    DtNetInt32       max_x;
    DtNetInt32       min_y;
    DtNetInt32       max_y;
    DtNetInt32       num_features; // physical features 
    DtNetInt32       patch_cache_size_map[CTDB_PATCH_CACHES];
    DtNetInt32       pad2;
    DtNetFloat64     origin_northing;
    DtNetFloat64     origin_easting;
    DtNetInt32       origin_zone_number;
    DtNetInt32       origin_zone_letter;
    DtNetInt32       datum;
    DtNetU8       name[CTDB_NAME_LENGTH];
    DtNetInt16       version;
    DtNetU8       date[CTDB_DATE_LENGTH];
    DtNetInt32       num_nodes;
    DtNetInt32       node_size;
    DtNetInt32       num_edges;
    DtNetInt32       edge_size;
    DtNetInt32       num_quad_data; // abstract features 
    DtNetInt32       n_patch_bytes;
    DtNetInt32       reserved[CTDB_HEADER_RESERVED];
};
 

/*
 * Patch group headers.
 */
class DT_DLL_ctdb c4b_patch_group_entry
{
  public:

    unsigned int  cache();
    bool mapped();
    bool contains_tins();
    bool patch0_occupied();
    bool patch0_dyn_terr();
    bool patch0_ta16();
    bool patch0_no_tas();
    bool patch1_occupied();
    bool patch1_dyn_terr();
    bool patch1_ta16();
    bool patch1_no_tas();
    bool patch2_occupied();
    bool patch2_dyn_terr();
    bool patch2_ta16();
    bool patch2_no_tas();
    bool patch3_occupied();
    bool patch3_dyn_terr();
    bool patch3_ta16();
    bool patch3_no_tas();
    unsigned int  unused();

    bool read(FILE* fp);
    void describe();

    unsigned int  offset();

  private:

    DtNetU32   data_start; // byte offset for patch group's data fromstart of all patch group data 
    DtNetU32   raw_bits;
};
    

class DT_DLL_ctdb c4b_patch_group_headers
{
  public:

    c4b_patch_group_headers(unsigned int num_patch_groups);

    int  num_in_x;
    int  num_in_y;
    int  num_patch_groups;

    c4b_patch_group_entry* entry;

    bool read(FILE* fp, bool debug = false);
};



/*
 * Topology -- Nodes.
 */
class DT_DLL_ctdb c4b_node_flags
{
  public:
  
    bool is_bridge();
    unsigned int  padding();
    DtU8 num_connections();

    void describe();

  private:
    DtNetU32   raw_bits;
};

class DT_DLL_ctdb c4b_node_ctdb_connection
{
  public:

    int  Node();
    int  Edge();

    bool read(FILE* fp);
    void describe();

  private:

    DtNetInt32 node;
    DtNetInt32 edge;
};

class DT_DLL_ctdb c4b_node
{
  public:

    DtFloat32     X();
    DtFloat32     Y();
    bool    read(FILE* fp);
    void    describe();

    c4b_node_flags   flags;
    c4b_node_ctdb_connection* connection;

  private:

    DtNetFloat32  x;
    DtNetFloat32  y;
};
    

/*
 * Topology -- Edges.
 */
class DT_DLL_ctdb c4b_edge_ctdb_feature_reference
{
  public:

    unsigned int  patch_offset();
    unsigned int  quad_offset();
    bool reverse();
    unsigned int  padding();
    bool is_abstract_feature();

    bool read(FILE *fp);
    void describe();

  private:

    DtNetU32   patch_number;
    DtNetU32   raw_bits;
};

class DT_DLL_ctdb c4b_edge
{
  public:

    bool read(FILE *fp);
    void describe();

  private:

    DtNetInt32 distance;
    DtNetInt32 first_node;
    DtNetInt32 last_node;
    DtNetInt32 num_features;
  
    c4b_edge_ctdb_feature_reference *feature;
};


/*
 * Abstract features. 
 */
class DT_DLL_ctdb c4b_abstract_feature_info
{
  public:

    bool read(FILE *fp);
    void describe();

  private:

    DtNetU8 type_code;
    DtNetU8 data_size;  // 4 byte units 
    DtNetU16   num_vertices;
};


/*
 * Feature data.
 */
class DT_DLL_ctdb c4b_xyo_coord2d
{
  public:

    void describe();

    void SetVec(DtPoint &v);
    double  X();
    double  Y();

  private:

    DtNetU16   x;
    DtNetU16   y;
};

class DT_DLL_ctdb c4b_patch_hdr
{
  public:

    DtU16   Size();
    void describe();

  private:

    DtNetU16   size;    // number of CTDB_FEATURE_DATA things in this patch (incl this hdr) 
    DtNetU16   pad;
};


static const int FT_MICRO    = 0;
static const int FT_BUILDING = 1;
static const int FT_TREE     = 2;
static const int FT_CANOPY   = 3;
static const int FT_LINEAR   = 4;

class DT_DLL_ctdb c4b_feature_info
{
  public:

    DtU8 FeatureType();
    DtU8 Vertices();
    unsigned int  PostMask();
    DtU8 MicroTerrainType();

    void describe();

  private:

    DtNetU32   raw_bits;
};


static const int CTDB_EDGE_KEY   = 4096;

class DT_DLL_ctdb c4b_linear_info
{
  public:

    double  Width();
    DtU8 Soil();
    DtU16   EdgeKey();

    void describe();

  private:

    DtNetU16   width;
    DtNetU16   soil_and_edge_key;
};


class DT_DLL_ctdb c4b_treeline_info
{
  public:

    double  Radius();
    bool First();
    bool Last();
    double  Height();
    void describe();

  private:

    DtNetU16   radius;
    DtNetU16   first_last_height;
};


class DT_DLL_ctdb c4b_micro_pts
{
  public:

    DtU8 Soil0();
    DtU8 Soil1();
    DtU8 Vert0();
    DtU8 Vert1();
    DtU8 Vert2();

    void describe();

  private:
    DtNetU8 soil0_and_soil1;
    DtNetU8 vert0;
    DtNetU8 vert1;
    DtNetU8 vert2;
};


/*
 * Grid post.
 */
class DT_DLL_ctdb c4b_grid_post
{
  public:

    DtU8 soil_of_northern_tri();
    DtU8 soil_of_southern_tri();
    bool either_tri_has_features();
    bool either_tri_has_buildings();
    bool either_tri_has_trees_or_treelines();
    bool either_tri_has_microterrain();
    int  scaled_elevation();

    bool read(FILE* fp);
    void describe();

  private:

    DtNetU32   raw_bits;
};


/*
 * Patch Terrain Elements.
 */
class DT_DLL_ctdb c4b_te_info
{
  public:

    void describe();

    DtU8 Blank1() { return((bvp&0xc0) >> 6); };
    DtU8 Vertices()  { return((bvp&0x30) >> 4); };
    DtU8 PatchAdj()  { return((bvp&0x0f)); };

    DtU8 Soil0()  { return(soil0); };
    DtU8 Soil1()  { return(soil1); };
    DtU8 AdjSides()  { return(adj_sides); };

  private:

    DtNetU8 bvp;
    DtNetU8 soil0;
    DtNetU8 soil1;
    DtNetU8 adj_sides;
};



static const int TE_VERT_DIMENSION  = 3;
static const int TE_ADJ_TRI_MAP_DIMENSION = 4;
template<class Type>class c4b_terrain_element
{
   public:

   void  describe()
   {
      DtInfo("template c4b_terrain_element::describe\n");
      
      DtInfo("  "); 
      pt.describe();
      
      double native_z = (double)z;
      DtInfo("  ");DtInfo("z=%lf\n", native_z);
      
      DtInfo("  ");
      vert.describe();
      
      DtInfo("  ");
      info.describe();
   }

   class c4b_assoc_vertex
   {
      public:

      void  describe()
      {
         DtInfo("c4b_assoc_vertex: ");

         for (int i = 0; i < TE_VERT_DIMENSION; i++)
         {
            DtInfo(" index[%d]=%u,", i, (DtU16) index[i]);
         }
         DtInfo("\n");
      }

      Type  index[TE_VERT_DIMENSION];
      Type  padding1;
   };

   c4b_xyo_coord2d  pt;
   DtNetFloat32     z;
   Type adj[TE_ADJ_TRI_MAP_DIMENSION];
   c4b_assoc_vertex vert;
   c4b_te_info      info;
};    

typedef c4b_terrain_element<DtNetU8>   c4b_terrain_element_8;
typedef c4b_terrain_element<DtNetU16>  c4b_terrain_element_16;


static const int CTDB_PATCHES_PER_GROUP = 4;
static const int CTDB_MAX_POSTS_PER_PATCH = 16;
/*
 *
 */
class DT_DLL_ctdb c4b_tin_pg_data
{
public:

    DtU16      Patch1Offset();
    DtU16      Patch2Offset();
    DtU16      Patch3Offset();
    void       describe();

//  private:

   DtNetFloat32   max_elev[CTDB_PATCHES_PER_GROUP];
   // In 32-bit words. 
   DtNetU16    patch1_offset;
   DtNetU16    patch2_offset;
   DtNetU16    patch3_offset;
   DtNetU16    unused;
   DtNetU8        feature_present[CTDB_MAX_POSTS_PER_PATCH * 2];
   DtNetU16    num_te[CTDB_PATCHES_PER_GROUP];
   DtNetU32    te_offset[CTDB_PATCHES_PER_GROUP];
   DtNetU8        te_vgrid_dim[CTDB_PATCHES_PER_GROUP];
   DtNetU32    te_vgrid_offset[CTDB_PATCHES_PER_GROUP];
};


class DT_DLL_ctdb c4b_grid_pg_data
{
public:

   DtU16    Patch1Offset();
   DtU16    Patch2Offset();
   DtU16    Patch3Offset();
   void     describe();

private:

   DtNetFloat32   max_elev[CTDB_PATCHES_PER_GROUP];
   // In 32-bit words. 
   DtNetU16    patch1_offset;
   DtNetU16    patch2_offset;
   DtNetU16    patch3_offset;
   DtNetU16    unused;
};


class C4B;
class MyC4BPatchGroup;

class DT_DLL_ctdb MyC4B
{
public:

   void     parse(C4B &c4b,
                  progressCallbackStartFunction *prog_start_fcnp,
                  progressCallbackSetValueFunction *prog_set_value_fcnp,
                  progressCallbackEndFunction *prog_end_fcnp);
   void     parse_soil_types(C4B &c4b);
   void     parse_grid_posts(C4B &c4b);
   void     xlate(C4B &c4b,
                  DtC4bReader* tdb,
                  progressCallbackStartFunction *prog_start_fcnp,
                  progressCallbackSetValueFunction *prog_set_value_fcnp,
                  progressCallbackEndFunction *prog_end_fcnp);
   void     xlate_soil_types(c4b_file_header &hdr);

   virtual DtC4bReader* reader() const;
   virtual void setReader(DtC4bReader* reader); 

   // increment the feature count of the terrain database as each new feature
   // is created, and return the updated count.
   int incrementTdbFeatureCount();

   MyC4BPatchGroup*  patch_group;
   DtGridPostList*   grid_post_vertex_list;

   DtSurfaceManager* mySurfaces;
   DtSurface*        myTree_surface;
   DtSurface*        myBuilding_surface;
    
   int*              tri1_soil_type;
   int*              tri2_soil_type;

   DtC4bReader*   myReader;
   int            myTdbFeatureCount;   // feature count in terrain database.
};


inline DtC4bReader* MyC4B::reader() const
{
   return myReader;
}


inline void MyC4B::setReader(DtC4bReader* reader)
{
   assert(reader != 0);
   myReader = reader; 
}


inline int MyC4B::incrementTdbFeatureCount()
{
   return(++myTdbFeatureCount);
}


/*
 *
 */
class DT_DLL_ctdb C4B
{
   public:

   bool  read(FILE* fp,
              progressCallbackStartFunction* prog_start_fcnp,
              progressCallbackSetValueFunction* prog_set_value_fcnp,
              progressCallbackEndFunction* prog_end_fcnp);
   void  describe();

   void  xlate(DtC4bReader* tdb,
               progressCallbackStartFunction* prog_start_fcnp,
               progressCallbackSetValueFunction* prog_set_value_fcnp,
               progressCallbackEndFunction* prog_end_fcnp);

   unsigned int patch0_number_from_patch_group_number(unsigned int patch_group_num);

   bool read_patch_group_headers(bool debug = false);
   bool read_nodes(bool debug = false);
   bool read_edges(bool debug = false); 
   bool read_feature_data();
   bool read_grid_posts(bool debug = false);
   bool read_all_patch_data(bool debug = false);

   // returns a pointer to a memory manager class that handles
   // allocations of a group of objects (polygons, groups, grids, 
   // features, etc.)
   virtual DtC4bReader* reader() const;

   FILE*             fp;

   c4b_file_header  my_ctdb;
   c4b_patch_group_headers*  patch_group_headers;
   c4b_node*        nodes;
   c4b_edge*        edges;

   c4b_grid_post*   grid_posts;

   unsigned int     num_grid_posts;

   DtU8*            patch_data;

   // Derived stuff. 
   void  unpack();
   unsigned int num_pages;
   unsigned int num_patches;
   unsigned int num_patch_groups;
   unsigned int num_patches_wide;
   unsigned int num_patches_high;
   unsigned int num_posts_wide;

   MyC4B parsed_c4b;
};


inline DtC4bReader* C4B::reader() const
{
   return(parsed_c4b.reader());
}



/*
 * Compact Terrain Database Format 4
 */
class DtMetafileRecord;

class DT_DLL_ctdb DtC4bReader: public DtTerrainReader
{
public:

    DtC4bReader();

    virtual ~DtC4bReader();

   // Override to set ourselves as the reader in my_ctdb, after calling
   // down to base class version.
   virtual void init(const DtFilename& filename, 
                     DtTerrainDatabase* terrain);

   // Loads terrain database file named filename, returning the data in 
   // terrain.  The terrain pointer passed in must be initialized before calling 
   // loadTerrain.
   virtual bool loadTerrain(const DtFilename& filename, 
                            DtTerrainDatabase* terrain);

   // Loads terrain database file named filename, returning the data in 
   // terrain.  The initializer object is used to pass in additional information
   // about the terrain to be loaded.  The terrain pointer passed in must be 
   // initialized before calling loadTerrain.
   virtual bool loadTerrain(const DtFilename& filename, 
                            DtTerrainDatabase* terrain, 
                            const DtTerrainInitializer* initializer);

   // Returns "c4b"
   virtual const DtString dataType() const;

   C4B   my_ctdb;

   static DtTerrainReader* create();

   // Returns only the coordinate system that would define this database.  Should not load
   // any polygonal or vector information
   virtual Coordinate_System* coordinateSystem(const DtFilename& filename);

   virtual int optionalFileFlags(const DtFilename& filename)
   {
      return 0;
   }

protected:

   bool read(const DtFilename& filename);
   bool import();
};

#endif