qtr.cpp

Go to the documentation of this file.

/*
 * QTR.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2003 Chris Wallace
 *
 * Fly! Legacy is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 * Fly! Legacy is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 *   along with Fly! Legacy; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "../Include/FlyLegacy.h"
#include "../Include/Globals.h"
#include "../Include/QTR.h"
#include "../Include/Utility.h"
#include "../Include/Endian.h"


CQTRFile::CQTRFile (void)
{
  header.numNodes = 0;
  header.magic = 50;
  header.width = 0;
  header.height = 0;
  header.rasterBytes = 0;
  for (int i=0; i<4; i++) header.elev[i] = 0;
}

CQTRFile::CQTRFile (int index)
{
  char qtrFilename[1024];
  sprintf (qtrFilename, "DATA\\%03X.QTR", index);
  Load (qtrFilename);
}

CQTRFile::CQTRFile (const char* qtrFilename)
{
  Load (qtrFilename);
}

CQTRFile::~CQTRFile (void)
{
  delete[] qtreenode;
  delete[] raster;
}

bool CQTRFile::Load (const char *qtrFilename)
{
  int i;
  
  PODFILE *p = popen (&globals->pfs, qtrFilename);
  if (p == NULL) {
    fprintf (stderr, "Error opening QTR filename : %s\n", qtrFilename);
    return false;
  }

  // Read QTR header
  size_t nRead = pread (&header, SIZEOF_QTR_HEADER, 1, p);
  if (nRead != 1) {
    pclose (p);
    return false;
  }

  // QTR data is stored in little-Endian format
  header.numNodes = LittleEndian (header.numNodes);
  header.magic = LittleEndian (header.magic);
  header.width = LittleEndian (header.width);
  header.height = LittleEndian (header.height);
  header.rasterBytes = LittleEndian (header.rasterBytes);
  for (i=0; i<4; i++) header.elev[i] = LittleEndian (header.elev[i]);

  // Allocate storage for quadtree nodes and read them
  qtreenode = new SQTRNode[header.numNodes];
  nRead = pread (qtreenode, SIZEOF_QTR_NODE, header.numNodes, p);
  if (nRead != header.numNodes) {
    pclose (p);
    return false;
  }

  // QTR data is stored in little-Endian format
  for (i=0; i<header.numNodes; i++) {
    SQTRNode *node = &qtreenode[i];

    node->center = LittleEndian (node->center);
    switch (node->type) {
    case QTR_NODE_BRANCH:
      node->branchData.nwNode = LittleEndian (node->branchData.nwNode);
      node->branchData.neNode = LittleEndian (node->branchData.neNode);
      node->branchData.swNode = LittleEndian (node->branchData.swNode);
      node->branchData.seNode = LittleEndian (node->branchData.seNode);
      break;

    case QTR_NODE_LEAF:
      node->leafData.nwElevation = LittleEndian (node->leafData.nwElevation);
      node->leafData.neElevation = LittleEndian (node->leafData.neElevation);
      node->leafData.swElevation = LittleEndian (node->leafData.swElevation);
      node->leafData.seElevation = LittleEndian (node->leafData.seElevation);
      break;

    case QTR_NODE_RASTER_ABS:
    case QTR_NODE_RASTER_REL:
      node->rasterData.offset = LittleEndian (node->rasterData.offset);
      node->rasterData.dummy = LittleEndian (node->rasterData.dummy);
      break;
    }
  }

  // Allocate storage for raster data and read it
  raster = new char[header.rasterBytes];
  nRead = pread (raster, sizeof(char), header.rasterBytes, p);
  if (nRead != header.rasterBytes) {
    pclose (p);
    return false;
  }

  pclose (p);
  return true;
}

/*
 * CQTRFile loader for standard (non-POD filesystem) I/O
 *

bool CQTRFile::Load (const char *qtrFilename)
{
  FILE *fQTR = fopen (qtrFilename, "rb");
  if (fQTR == NULL) {
    fprintf (stderr, "Error opening QTR filename : %s\n", qtrFilename);
    return false;
  }

  // Read QTR header
  size_t nRead = fread (&header, sizeof(SQTRHeader), 1, fQTR);
  if (nRead != 1) {
    fclose (fQTR);
    return false;
  }

  // Allocate storage for quadtree nodes and read them
  qtreenode = new SQTRNode[header.numNodes];
  nRead = fread (qtreenode, sizeof(SQTRNode), header.numNodes, fQTR);
  if (nRead != header.numNodes) {
    fclose (fQTR);
    return false;
  }

  // Allocate storage for raster data and read it
  raster = new char[header.rasterBytes];
  nRead = fread (raster, sizeof(char), header.rasterBytes, fQTR);
  if (nRead != header.rasterBytes) {
    fclose (fQTR);
    return false;
  }

  fclose (fQTR);
  return true;
}
*/

bool CQTRFile::Save (const char *qtrFilename)
{
  FILE *fQTR = fopen (qtrFilename, "wb");
  if (fQTR == NULL) {
    fprintf (stderr, "Error opening QTR filename : %s\n", qtrFilename);
    return false;
  }

  // Write QTR header
  size_t nWrite = fwrite (&header, sizeof(SQTRHeader), 1, fQTR);
  if (nWrite != 1) {
    fclose (fQTR);
    return false;
  }

  // Write quadtree nodes
  nWrite = fwrite (qtreenode, sizeof(SQTRNode), header.numNodes, fQTR);
  if (nWrite != header.numNodes) {
    fclose (fQTR);
    return false;
  }

  // Write raster data
  nWrite = fwrite (raster, sizeof(char), header.rasterBytes, fQTR);
  if (nWrite != header.rasterBytes) {
    fclose (fQTR);
    return false;
  }

  fclose (fQTR);
  return true;
}

unsigned short CQTRFile::NumQuadtreeNodes (void)
{
  return header.numNodes;
}

SQTRNode *CQTRFile::GetQuadtreeNode (unsigned short i)
{
  SQTRNode *rc = NULL;
  if (i < header.numNodes) {
    rc = &qtreenode[i];
  }
  return rc;
}

char* CQTRFile::GetRasterData (unsigned long offset)
{
  char* rc = NULL;
  if (offset <= header.rasterBytes) {
    rc = &raster[offset];
  }
  return rc;
}

//
// Extract a single value from an 8x8 relative raster data block.
//
float CQTRFile::ExtractRelativeData (char* data, int x, int z)
{
  short *pBase = (short *)data;
  short base = *pBase;
  data += sizeof(short);
  unsigned char offset = data[(z * 8) + x];
  short metres = base + (offset * 16);
  return MetresToFeet ((float)metres);
}

//
// Extract a single value from an 8x8 absolute raster data block.
//
float CQTRFile::ExtractAbsoluteData (short* data, int x, int z)
{
  float metres = (float)(data[(z * 8) + x]);
  return MetresToFeet (metres);
}

//
// Search the quadtree starting at the given node, at the given level
//
// Parameters:
//   level    Depth to which to search, the root node is at level zero
//   x        x (east/west) index
//   z        z (north/south) index
//
// Return Value:
//   float    Elevation value in feet MSL
//
float CQTRFile::Search (int level, unsigned short node, int x, int z)
{
  float rc = 0.0f;

  SQTRNode *qtrnode = GetQuadtreeNode (node);

  if (level == 0) {
    // Desired search level has been reached
    rc = qtrnode->center;
  } else {
    // Determine quadrant
    //   NW = 00 = 0     NE = 01 = 1
    //   SW = 10 = 2     SE = 11 = 3
    int half = 1 << (level - 1);
    int qx = (x / half) % 2;
    int qz = (z / half) % 2;
    int quadrant = qx * 2 + qz;
    int xNew = x % half;
    int zNew = z % half;

    // Check node type
    switch (qtrnode->type) {
    case QTR_NODE_LEAF:
      // Return elevation from the proper quadrant
      switch (quadrant) {
      case 0:
        rc = qtrnode->leafData.nwElevation;
        break;
      case 1:
        rc = qtrnode->leafData.neElevation;
        break;
      case 2:
        rc = qtrnode->leafData.swElevation;
        break;
      case 3:
        rc = qtrnode->leafData.seElevation;
        break;
      default:
        gtfo ("CQTRFile::Search : Invalid quadrant");
      }
      break;

    case QTR_NODE_BRANCH:
      // Recursively traverse down one level
      switch (quadrant) {
      case 0:
        rc = Search (level-1, qtrnode->branchData.nwNode, xNew, zNew);
        break;
      case 1:
        rc = Search (level-1, qtrnode->branchData.swNode, xNew, zNew);
        break;
      case 2:
        rc = Search (level-1, qtrnode->branchData.neNode, xNew, zNew);
        break;
      case 3:
        rc = Search (level-1, qtrnode->branchData.seNode, xNew, zNew);
        break;
      default:
        gtfo ("CQTRFile::Search : Invalid quadrant");
      }
      break;

    case QTR_NODE_RASTER_REL:
      {
        // Extract elevation from relative raster data block
        if (level != 3) {
          gtfo ("CQTRFile : Attempt to traverse relative raster data block at level %d",
            level);
        }
        int rasterSize = 1 << level;
        int xr = x % rasterSize;
        int zr = z % rasterSize;
        rc = ExtractRelativeData (GetRasterData(qtrnode->rasterData.offset), xr, zr);
      }
      break;

    case QTR_NODE_RASTER_ABS:
      {
        // Extract elevation from absolute raster data block
        if (level != 3) {
          gtfo ("CQTRFile : Attempt to traverse absolute raster data block at level %d",
            level);
        }
        int rasterSize = 1 << level;
        int xr = x % rasterSize;
        int zr = z % rasterSize;
        rc = ExtractAbsoluteData ((short *)GetRasterData(qtrnode->rasterData.offset),
          xr, zr);
      }
      break;
    }
  }

  return rc;
}

//
// Dump contents to a text file
//
void CQTRFile::Dump (const char* txtFilename)
{
  FILE *fOut = fopen (txtFilename, "w");

  int nBranchNodes = 0;
  int nLeafNodes = 0;
  int nRelativeNodes = 0;
  int nAbsoluteNodes = 0;

  // Display QTR header
  fprintf (fOut, "QTR Header:\n\n");
  fprintf (fOut, "  numNodes   : %d\n", header.numNodes);
  fprintf (fOut, "  dimensions : %d x %d\n", header.width, header.height);
  fprintf (fOut, "  elevations : NW=%d NE=%d SW=%d SE=%d\n",
    header.elev[0], header.elev[1], header.elev[2], header.elev[3]);
  fprintf (fOut, "  rasterBytes: %d\n", header.rasterBytes);
  fprintf (fOut, "\n");

  // Display quadtree nodes
  for (unsigned short i=0; i<header.numNodes; i++) {
    // Get node data
    SQTRNode *node = &qtreenode[i];

    fprintf (fOut, "Node %05d: ", i);
    switch (node->type) {
    case QTR_NODE_BRANCH:
      {
        nBranchNodes++;

        fprintf (fOut, "BRANCH    center=%5d  NW=%05d NE=%05d SW=%05d SE=%05d\n",
          node->center,
          node->branchData.nwNode,
          node->branchData.neNode,
          node->branchData.swNode,
          node->branchData.seNode);
      }
      break;
    case QTR_NODE_LEAF:
      {
        nLeafNodes++;

        fprintf (fOut, "LEAF      center=%05d  NW=%05d NE=%05d SW=%05d SE=%05d\n",
          node->center,
          node->leafData.nwElevation,
          node->leafData.neElevation,
          node->leafData.swElevation,
          node->leafData.seElevation);
      }
      break;
    case QTR_NODE_RASTER_REL:
      {
        nRelativeNodes++;

        char *pData = GetRasterData (node->rasterData.offset);
        short base = *((short *)pData);
        pData += sizeof(short);

        fprintf (fOut, "RELATIVE  center=%5d offset=0x%08X dummy=0x%08X base=%5d\n",
          node->center,
          node->rasterData.offset,
          node->rasterData.dummy,
          base);
        for (int row=0; row<8; row++) {
          fprintf (fOut, "           ");
          for (int col=0; col<8; col++) {
            unsigned char c = pData[row * 8 + col];
            fprintf (fOut, "%5d  ", c);
          }
          fprintf (fOut, "\n");
        }
      }
      break;
    case QTR_NODE_RASTER_ABS:
      {
        nAbsoluteNodes++;

        short *pData = (short *)(GetRasterData (node->rasterData.offset));

        fprintf (fOut, "ABSOLUTE  center=%5d  offset=0x%08X, dummy=0x%08X\n",
          node->center,
          node->rasterData.offset,
          node->rasterData.dummy);
        for (int row=0; row<8; row++) {
          fprintf (fOut, "           ");
          for (int col=0; col<8; col++) {
            short s = pData[row * 8 + col];
            fprintf (fOut, "%5d  ", s);
          }
          fprintf (fOut, "\n");
        }
      }
      break;
    default:
      fprintf (fOut, "*** Unknown node type 0x%02X\n");
    }
  }

  // Summary statistics
  fprintf (fOut, "\n");
  fprintf (fOut, "nBranchNodes   = %d\n", nBranchNodes);
  fprintf (fOut, "nLeafNodes     = %d\n", nLeafNodes);
  fprintf (fOut, "nRelativeNodes = %d\n", nRelativeNodes);
  fprintf (fOut, "nAbsoluteNodes = %d\n", nAbsoluteNodes);

  fclose (fOut);
}

Documentation generated by