table3d_interpolate.h

Go to the documentation of this file.

#pragma once
 
#include <iterator>
#include "table3d_typedefs.h"
#include "maths.h"
#include "table2d.h"
 
struct xy_pair_t
{
  uint16_t x;
  uint16_t y;
 
  friend bool operator==(const xy_pair_t& lhs, const xy_pair_t& rhs)
  {
      return lhs.x==rhs.x && lhs.y==rhs.y;
  }
};
 
struct xy_coord2d
{
  table3d_dim_t x;
  table3d_dim_t y;
};
 
struct table3DGetValueCache {
  // Store the upper *index* of the X and Y axis bins that were last hit.
  // This is used to make the next check faster since very likely the x & y values have
  // only changed by a small amount & are in the same bin (or an adjacent bin).
  //
  // It's implicit that the other bin index is max bin index - 1 (a single axis
  // value can't span 2 axis bins). This saves 1 byte.
  //
  // E.g. 6 element x-axis contents:
  //   [ 8| 9|12|15|18|21]
  // indices:
  //     0, 1, 2, 3, 4, 5
  // If lastXBinMax==3, the min index must be 2. I.e. the last X value looked
  // up was between 12<X<=15.
  xy_coord2d lastBinMax = { 1U, 1U };
 
  //Store the last input and output values, again for caching purposes
  xy_pair_t last_lookup = { UINT16_MAX, UINT16_MAX };
  table3d_value_t lastOutput;
};
 
static inline void invalidate_cache(table3DGetValueCache *pCache)
{
    pCache->last_lookup.x = UINT16_MAX;
}
 
// private to table3D implementation
using table3d_bin_t = _table2d_detail::Bin<table3d_axis_t>;
 
extern table3d_value_t interpolate_3d_value(const xy_pair_t &lookUpValues, 
                    const table3d_dim_t &axisSize,
                    const table3d_value_t *pValues,
                    const table3d_bin_t &xBin,
                    const uint16_t xMultiplier,
                    const table3d_bin_t &yBin,
                    const uint16_t yMultiplier);
 
 
template <uint16_t xFactor, uint16_t yFactor, typename TValues, typename TXAxis, typename TYAxis>
table3d_value_t get3DTableValue(struct table3DGetValueCache *pValueCache, 
                    const TValues &values,
                    const TXAxis &xAxis,
                    const TYAxis &yAxis,
                    const xy_pair_t &lookupValues) {
  
#if !defined(UNIT_TEST) // No caching during unit testing
  // Check if the lookup values are the same as the last time we looked up a value
  // If they are, we can return the cached value
  if( lookupValues == pValueCache->last_lookup)
  {
    return pValueCache->lastOutput;
  }
#endif
 
  constexpr table3d_dim_t axisSize = std::tuple_size<TXAxis>::value;
 
  // Figure out where on the axes the incoming coord are
  auto xBin = _table2d_detail::findCachedBin(pValueCache->lastBinMax.x, std::begin(xAxis), std::end(xAxis), (table3d_dim_t)div_round_closest_u16<xFactor>(lookupValues.x));
  auto yBin = _table2d_detail::findCachedBin(pValueCache->lastBinMax.y, std::begin(yAxis), std::end(yAxis), (table3d_dim_t)div_round_closest_u16<yFactor>(lookupValues.y));
  
  // Interpolate based on the bin positions
  pValueCache->lastOutput = interpolate_3d_value(lookupValues, axisSize, values.data(), xBin, xFactor, yBin, yFactor);
  // Store the last lookup values so we can check them next time
  pValueCache->last_lookup = lookupValues;
  pValueCache->lastBinMax.x = xBin.upperIndex;
  pValueCache->lastBinMax.y = yBin.upperIndex;
 
  return pValueCache->lastOutput;
 
}
 
struct row_col2d {
  table3d_dim_t row;
  table3d_dim_t col;
};