BaseObjects.cpp

Go to the documentation of this file.

/*
 * DataMap.cpp
 *
 * Part of Fly! Legacy project
 *
 * Copyright 2004 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/Utility.h"
#include "../Include/Globals.h"

#include <map>
using namespace std;


//
// CDataMapCoefficient
//
// This CDataLookup implements a simple linear mapping:
//
//  y = a * x;
//

class CDataMapCoefficient : public CDataLookup {
public:
  // Constructors / Destructor
  CDataMapCoefficient (float f);

  // CDataLookup methods
  float Lookup (float x);
  
protected:
  float a;        // Linear coefficient
};

CDataMapCoefficient::CDataMapCoefficient (float f)
{
  this->a = f;
}

float CDataMapCoefficient::Lookup (float x)
{
  return x * a;
}

//
// CDataMapPolynomial
//
// This CDataLookup implements a polynomial mapping up to 9th order:
//
//                              2                 9
//   y = a0 + (a1 * x) + (a2 * x)  + ... + (a9 * x)
//
//
class CDataMapPolynomial : public CStreamObject, public CDataLookup {
public:
  // Constructors / Destructor
  CDataMapPolynomial (void);
//  CDataMapPolynomial (CDataMapPolynomial *p1,
//                      CDataMapPolynomial *p2,
//                      float scale)

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CDataLookup methods
  float Lookup (float x);
  void  Interpolate (CDataMapPolynomial *p1,
                     CDataMapPolynomial *p2,
                     float scale);

  // CDataMapPolynomial methods
  void  SetCoefficient (int i, float f);

protected:
  float coeff[10];     // Polynomial coefficients
};

CDataMapPolynomial::CDataMapPolynomial (void)
{
  int i;
  for (i=0; i<10; i++) coeff[i] = 0.0f;
}

//
// This constructor creates a polynomial with interpolated coefficients
//
void CDataMapPolynomial::Interpolate (CDataMapPolynomial *p1,
                                      CDataMapPolynomial *p2,
                                      float scale)
{
  int i;
  for (i=0; i<10; i++) {
    float d = p2->coeff[i] - p1->coeff[i];
    coeff[i] = p1->coeff[i] + (d * scale);
  }
}

void CDataMapPolynomial::SetCoefficient (int i, float a)
{
  if (i < 10) coeff[i] = a;
}

int CDataMapPolynomial::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  switch (tag) {
  case 'coef':
    {
      // From zero to four coefficients may be present
      char s[80];
      ReadString (s, 80, stream);

      char *delimiters = " \t";
      char *token = strtok (s, delimiters);
      int i = 0;
      while ((token != NULL) && (i < 10)) {
        float f = atof (token);
        SetCoefficient (i, f);
        token = strtok (NULL, delimiters);
        i++;
      }
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDataMapPolynomial::Read : Unknown tag %s", s);
  }

  return rc;
}

float CDataMapPolynomial::Lookup (float x)
{
  float y = coeff[0];
  int i;
  for (i=1; i<10; i++) {
    if (coeff[i] != 0) {
      y += coeff[i] * x;
    }
    x *= x;
  }
  return y;
}


//
// CDataMapTable
//
// The table mapping is the most complex (and flexible) method.  There are two
//   basic subtypes of tables : <fmt1> and <fmt3>
//
// <fmt1> tables use a list of x,y data points to define the mapping curve.
//   Simple linear interpolation between the data points is used for x-values
//   that are not explicitly listed in the table data point list
//
// <fmt3> tables use a list of x-values and list of up to four polynomials
//   that define a cubic polynomial to be applied at that x-value until the
//   next breakpoint.
//

typedef enum {
  TABLE_FORMAT_UNKNOWN,
  TABLE_FORMAT_1,
  TABLE_FORMAT_3
} ETableFormat;

typedef struct {
  float x;
  float y;
} SFmt1Entry;

class CFmt3Entry {
public:
  CFmt3Entry (void);
  virtual ~CFmt3Entry (void);

public:
  float               x;
  CDataMapPolynomial *poly;
};

CFmt3Entry::CFmt3Entry (void)
{
  x = 0;
  poly = new CDataMapPolynomial;
}

CFmt3Entry::~CFmt3Entry (void)
{
  delete poly;
}


class CDataMapTable : public CDataLookup, public CStreamObject {
public:
  // Constructors
  CDataMapTable (void);

  // CStreamObject methods
  int   Read (SStream *stream, Tag tag);

  // CDataLookup methods
  float     Lookup (float x);

  // CDataMapTable methods
  float     LookupFmt1 (float x);
  float     LookupFmt3 (float x);

protected:
  ETableFormat                   format;
  vector<SFmt1Entry>             fmt1;
  vector<CFmt3Entry>             fmt3;
};

CDataMapTable::CDataMapTable (void)
{
  format = TABLE_FORMAT_UNKNOWN;
}

int CDataMapTable::Read (SStream *stream, Tag tag)
{
  char s[256];

  int rc = TAG_IGNORED;

  switch (tag) {
  case 'fmt1':
    // Format 1 table, simple mapping of x to y values with linear interpolation
    format = TABLE_FORMAT_1;
    ReadString (s, 256, stream);
    while (strstr (s, "<endf>") == NULL) {
      // Parse an x y data pair
      SFmt1Entry entry;
      if (sscanf (s, "%f %f", &entry.x, &entry.y) == 2) {
        fmt1.push_back (entry);
      } else {
        // Generate warning
        globals->logWarning->Write ("CDataMapTable : Invalid <fmt1> data %s", s);
      }

      // Read next line
//      ReadString (s, 256, stream);
    }
    rc = TAG_READ;
    break;

  case 'fmt3':
    // Format 3 table of polynomial expressions
    format = TABLE_FORMAT_3;
    ReadString (s, 256, stream);
    while (strstr (s, "<endf>") == NULL) {
      CFmt3Entry entry;
      // Parse breakpoint x-value and polynomial coefficients
      char *delimiters = " \t";
      char *token = strtok (s, delimiters);
      entry.x = atof (token);

      token = strtok (NULL, delimiters);
      int i = 0;
      while ((token != NULL) && (i < 10)) {
        float f = atof (token);
        entry.poly->SetCoefficient (i, f);
        token = strtok (NULL, delimiters);
        i++;
      }
      fmt3.push_back (entry);
        // Instantiate new polynomial lookup
//        CDataMapPolynomial *poly = new CDataMapPolynomial;
//        for (int i=1; i<nArgs; i++) {
//          poly->SetCoefficient (i-1, coeff[i-1]);
//        }
        // Add coefficient to breakpoint list
//        fmt3[x] = poly;
//      } else {
        // Generate warning
//        globals->logWarning->Write ("CDataMapTable : Invalid <fmt3> data %s", s);
//      }

      // Read next line
//      ReadString (s, 256, stream);
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDataMapTable::Read : Unknown tag %s", s);
  }

  return rc;
}

float CDataMapTable::LookupFmt1 (float x)
{
  float y = 0.0f;

  if (!fmt1.empty()) {

    // Get references to first and last elements
    SFmt1Entry &front = fmt1.front();
    SFmt1Entry &back = fmt1.back();

    // Check for x-value below minimum breakpoint
    if (x <= front.x) {
      y = front.y;
    } else if (x >= back.x) {
      y = back.y;
    } else {
      // x-value is within table, need to find bracketing entries and iterpolate
      float x1, y1, x2, y2;
      vector<SFmt1Entry>::iterator i = fmt1.begin();
      x1 = 0;
      y1 = 0;
      x2 = i->x;
      y2 = i->y;
      i++;
      while ((i != fmt1.end()) && (x < x2)) {
        // Transfer upper bound to lower bound
        x1 = x2;
        y1 = y2;

        // Set new upper bound
        x2 = i->x;
        y2 = i->y;

        // Iterate to next element in the map
        i++;
      }

      // Interpolate between the two values
      float dy = y2 - y1;
      float dx = x2 - x1;
      y = y1 + (dy * ((x - x1) / dx));
    }
  }

  return y;
}

float CDataMapTable::LookupFmt3 (float x)
{
  float y = 0.0f;

  // Each table entry in a fmt3 table is a set of up to ten polynomial
  //   equation coefficients a0, a1, ... a9.  The mapping function at
  //   each breakpoint is defined as:
  //     y = a0 + (a1 * x) + (a2 * x^2) + ... + (a9 * x^9)
  //
  if (!fmt3.empty()) {

    // Get references to first and last elements
    CFmt3Entry &front = fmt3.front();
    CFmt3Entry &back = fmt3.back();

    if (x <= front.x) {
      // Lookup value is less than minimum breakpoint
      y = front.poly->Lookup (x);
    } else if (x >= back.x) {
      // Lookup value is greater than maximum breakpoint
      y = back.poly->Lookup (x);
    } else {
      // x-value is within table, need to find bracketing entries and iterpolate
      float x1, x2;
      CDataMapPolynomial *poly1, *poly2;
      vector<CFmt3Entry>::iterator i = fmt3.begin();
      x1 = 0;
      poly1 = NULL;
      x2 = i->x;
      poly2 = i->poly;
      i++;
      while ((i != fmt3.end()) && (x < x2)) {
        // Transfer upper bound to lower bound
        x1 = x2;
        poly1 = poly2;

        // Set new upper bound
        x2 = i->x;
        poly2 = i->poly;

        // Iterate to next element in the map
        i++;
      }

      // Interpolate the polynomials
      float dx = x2 - x1;
      CDataMapPolynomial poly;
      poly.Interpolate (poly1, poly2, (x - x1) / dx);
      y = poly.Lookup (x);
    }
  }

  return y;
}

float CDataMapTable::Lookup (float x)
{
  float y = 0.0f;

  switch (format) {
  case TABLE_FORMAT_1:
    y = LookupFmt1 (x);
    break;
  case TABLE_FORMAT_3:
    y = LookupFmt3 (x);
    break;
  default:
    // Undefined table format
    gtfo ("CDataMapTable::Lookup : Undefined table format : %d", format);
  }

  return y;
}


//
// CDataMap
//
CDataMap::CDataMap (void)
{
  dataSource = NULL;
}

int CDataMap::Read (SStream *stream, Tag tag)
{
  int rc = TAG_IGNORED;

  // Multiple data map specifications can exist; only the last one is used,
  //   previous ones are ignored.  If the tag is a valid data map type,
  //   and the dataSource pointer has already been set, then we need to
  //   delete the old object before instantiating the new one

  switch (tag) {
  case 'cof1':
  case 'ply1':
  case 'tbl1':
    // Valid data map type
    if (dataSource != NULL) {
      // This spec overrides previous one; delete object first
      delete dataSource;
      dataSource = NULL;
    }
    break;
  }

  // Now instantiate the proper data map specification
  switch (tag) {
  case 'cof1':
    // Simple linear coefficient
    float f;
    ReadFloat (&f, stream);
    dataSource = new CDataMapCoefficient(f);
    rc = TAG_READ;
    break;

  case 'ply1':
    {
      // Polynomial a + bx + cx^2 + dx^3
      CDataMapPolynomial *poly = new CDataMapPolynomial;
      ReadFrom (poly, stream);
      dataSource = poly;
    }
    rc = TAG_READ;
    break;

  case 'tbl1':
    {
      // Data table
      CDataMapTable *table = new CDataMapTable;
      ReadFrom (table, stream);
      dataSource = table;
    }
    rc = TAG_READ;
    break;
  }

  if (rc == TAG_IGNORED) {
    char s[64];
    TagToString (s, tag);
    globals->logWarning->Write ("CDataMap::Read : Unknown tag %s", s);
  }

  return rc;
}

float CDataMap::Lookup (float x)
{
  float rc = 0.0f;
  if (dataSource != NULL) {
    rc = dataSource->Lookup(x);
  }
  return rc;
}

/*


  
//
// CTuple is a single entry in a format 1 table, consisting of a simple x,y
//   data pair.
//

class CTuple {
public:
  CTuple (float initX, float initY) : x(initX), y(initY) {}

  //
  // Static function to linearly interpolate between two CTuple instances.
  //   The tuples must be ordered such that t1.x < t2.x.
  //
  static float Interpolate (float x, CTuple *t1, CTuple *t2)
  {
    if (x <= t1->x) return t1->y;
    if (x >= t2->x) return t2->y;
    float dx = t2->x - t1->x;
    return t1->y + ((t2->y - t1->y) * ((x - t1->x) / dx));
  }

public:
  float x, y;
};


//
// CPolynomial is a single entry in a format 1 table, representing a cubic
//   polynomial of the form y = a0 + (a1 * x) + (a2 * x^2) + (a3 * x^3)
//

class CPolynomial {
public:
  CPolynomial (int n, float initX, float initA0, float initA1, float initA2, float initA3)
  {
    x = a0 = a1 = a2 = a3 = 0;
    x = initX;
    if (n > 0) a0 = initA0;
    if (n > 1) a1 = initA1;
    if (n > 2) a2 = initA2;
    if (n > 3) a3 = initA3;
  }

  float Evaluate (float x)
  {
    float x2 = x * x;
    return a0 + (a1 * x) + (a2 * x2) + (a3 * x * x2);
  }

public:
  float x;
  float a0, a1, a2, a3;
};


*/

Documentation generated by