vee_interpolators.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_INTERPOLATORS_H
#define VEE_INTERPOLATORS_H

#include <vector>

#include <string.h>  // bzero for Linux
#include <strings.h> // bzero for SGI

template <typename T>
class VEE_InterpolationPoint
{
public:
  VEE_InterpolationPoint() {}

  VEE_InterpolationPoint(const T &value, float time)
    : m_value(value), m_time(time) {}

  T     m_value;
  float m_time;
};

template <typename T>
class VEE_LinearInterpolation
{
public:
  VEE_LinearInterpolation() : m_index(0) {}
  ~VEE_LinearInterpolation() {}

  void clear() { m_index = 0; m_points.resize(0); }

  inline T getValue(float t)
  {
    T res;

    seekInterval(t);
    
    if(m_index >= m_points.size()) {
      bzero(&res, sizeof(res));
      return res;
    }

    if(m_index + 1 == m_points.size()) {
      return m_points[m_index].m_value;
    }

    return interpolate(m_points[m_index], m_points[m_index + 1], t);  
  }

  inline T getValueBisect(float t) const
  {
    T res;

    if(!m_points.size()) {
      bzero(&res, sizeof(res));
      return res;      
    }

    uint higher = m_points.size() - 1;
    uint lower = 0;

    while(higher > lower + 1) {
      uint center = (higher + lower) >> 1;
      if(m_points[center].m_time > t)
  higher = center;
      else
  lower = center;
    }
    
    if(m_points[higher].m_time <= t)
      return m_points[higher].m_value;

    return interpolate(m_points[lower], m_points[higher], t); 
  }

  inline T getValueFast(float t)
  {
    T res;

    seekInterval(t);
    
    if(m_index >= m_points.size()) {
      bzero(&res, sizeof(res));
      return res;
    }

    return m_points[m_index].m_value;
  }

  void appendPoint(const T & v, float t)
  { 
    unsigned s = m_points.size();
    if(s) {
      if(m_points[s - 1].m_time == t) {
  m_points[s - 1].m_value = v;
  return;
      }
  
    }
    m_points.push_back(VEE_InterpolationPoint<T>(v, t)); 
  }

  bool atEnd() const 
  {
    if(!m_points.size())
      return true;
    return m_index + 1 >= m_points.size();
  }

  unsigned size() { return m_points.size(); }

  VEE_InterpolationPoint<T> & getPoint(uint i) { return m_points[i]; }

  static inline T interpolate(const VEE_InterpolationPoint<T> & p1, 
            const VEE_InterpolationPoint<T> & p2, 
            float t)
  { 
    float diff = p2.m_time - p1.m_time;

    if(diff < 1.0e-8)
      return p2.m_value;

    float mix  = (t - p1.m_time) / diff;
    return interpolate(p2.m_value, p1.m_value, mix);
  }
  
  static inline T interpolate(const T & v1, const T & v2, float mix)
  { return v1 * mix + v2 * (1.0 - mix); }

  float endTime() const 
  { return m_points.size() ? m_points[m_points.size()-1].m_time : 0.0f; }

  void moveTime(float offset)
  { for(uint i=0; i < m_points.size(); i++) m_points[i].m_time += offset; }

protected:

  void seekInterval(float t)
  {
    unsigned n = m_points.size();

    while(m_index < n) {

      VEE_InterpolationPoint<T> *p = & m_points[m_index];

      if(p->m_time < t) {
  // Moving forward

  if(m_index + 1 >= n)  // At end
    return;
  if(m_points[m_index + 1].m_time < t) // Go forward
    m_index++;
  else // Found the correct interval
    return;
      }
      else if(p->m_time > t) {
  // Moving backward
  if(!m_index) return; // At beginning
  m_index--;
      }
      else // p->m_time == t
  return;
    }
  }

  std::vector<VEE_InterpolationPoint<T> > m_points;
  unsigned m_index;
};

/* template <>
VEE_Matrix3 VEE_LinearInterpolation<VEE_Matrix3>::interpolate
(const VEE_Matrix3 & v1, const VEE_Matrix3 & v2, float mix)
{
  float xa1, ya1, za1;
  float xa2, ya2, za2;
  
  v1.getRotationXYZ(xa1, ya1, za1);
  v2.getRotationXYZ(xa2, ya2, za2);
  
  }*/


template <typename T>
class VEE_LinearInterpolation2 : public VEE_LinearInterpolation<T>
{
public:
  VEE_LinearInterpolation2() : m_time(0.0) {}
  ~VEE_LinearInterpolation2() {}

  void move(float dt) { m_time += dt; }
  void reset(float time = 0.0) 
  { m_time = time; m_index = 0; seekInterval(time); }

  float time() const { return m_time; }
  
  T getValue2() { return getValue(m_time); }

protected:
  float m_time;
};

#endif

---