interpolation_array.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2012-2015 Joerg Henrichs
//
//  This program 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 3
//  of the License, or (at your option) any later version.
//
//  This program 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 
#ifndef HEADER_INTERPOLATION_ARRAY_HPP
#define HEADER_INTERPOLATION_ARRAY_HPP
 
#include <assert.h>
#include <vector>
 
class InterpolationArray
{
private:
    std::vector<float> m_x;
 
    std::vector<float> m_y;
 
    /* Pre-computed (x[i+1]-x[i])/(y[i+1]/-y[i]) . */
    std::vector<float> m_delta;
 
public:
    InterpolationArray() {};
 
    void clear()
    {
        m_x.clear();
        m_y.clear();
        m_delta.clear();
    }
 
    int push_back(float x, float y)
    {
        if(m_x.size()>0 && x < m_x[m_x.size()-1])
            return 0;
        m_x.push_back(x);
        m_y.push_back(y);
        if(m_y.size()>1)
        {
            const unsigned int last=(unsigned int) m_x.size()-1;
            // Avoid division by zero, just set m_delta to a large
            // value with the right sign
            if(m_x[last]==m_x[last-1])
                m_delta.push_back( (m_y[last]-m_y[last-1])
                                  / 0.001f                 );
            else
                m_delta.push_back( (m_y[last]-m_y[last-1])
                                 /(m_x[last]-m_x[last-1])  );
        }
        return 1;
    }   // push_back
    // ------------------------------------------------------------------------
    unsigned int size() const { return (unsigned int) m_x.size(); }
    // ------------------------------------------------------------------------
    float getX(unsigned int i) const { return m_x[i]; }
    // ------------------------------------------------------------------------
    float getY(unsigned int i) const { return m_y[i]; }
    // ------------------------------------------------------------------------
    void setY(unsigned int i, float y)
    {
        m_y[i] = y;
        if(i>0)
            m_delta[i-1] = (m_y[i]-m_y[i-1])
                          /(m_x[i]-m_x[i-1]);
        if(i<m_y.size()-1)
            m_delta[i] = (m_y[i+1]-m_y[i])
                        /(m_x[i+1]-m_x[i]);
    }
    // ------------------------------------------------------------------------
    float get(float x) const
    {
        if(m_x.size()==1 || x<m_x[0])
            return m_y[0];
 
        if(x>m_x[m_x.size()-1])
            return m_y[m_y.size()-1];
 
        // Now x must be between two points in m_x
        // The array size in STK are pretty small (typically 3 or 4),
        // so not worth the effort to do a binary search
        for(unsigned int i=1; i<m_x.size(); i++)
        {
            if(x >m_x[i]) continue;
            return m_y[i-1] + m_delta[i-1] * (x - m_x[i-1]);
        }
        assert(false); return 0;  // keep compiler happy
    }   // get
 
    // ------------------------------------------------------------------------
    float getReverse(float y) const
    {
        if(m_y.size()==1) return m_x[0];
 
        if(m_y[1]<m_y[0])   // if decreasing values
        {
            if(y > m_y[0]) return m_x[0];
 
            const unsigned int last = (unsigned int) m_x.size();
 
            for(unsigned int i=1; i<last; i++)
            {
                if(y < m_y[i]) continue;
                return m_x[i-1] + (y-m_y[i-1])/ m_delta[i-1];
            }   // for i < last
            return m_x[last-1];
        }
        else   // increasing
        {
            if(y < m_y[0]) return m_x[0];
 
            const unsigned int last = (unsigned int) m_x.size();
 
            for(unsigned int i=1; i<last; i++)
            {
                if(y > m_y[i]) continue;
                return m_x[i-1] + (y-m_y[i-1]) / m_delta[i-1];
            }   // for i < last
            return m_x[last-1];
        }   // increasing
    }   // getReverse
};    // InterpolationArray
 
 
#endif