HermiteCurve.h

/*
 *   Copyright 2011, 2012 Lukas Jirkovsky
 *
 *   This file is part of FotoSHOCK.
 *
 *   FotoSHOCK 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, version 3 of the License.
 *
 *   FotoSHOCK 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 FotoSHOCK.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef HERMITECURVE_H
#define HERMITECURVE_H

#include <QVector>
#include <QPoint>

#include <stdint.h>

class QHermiteControlPoint : public QPoint {
    public:
        QHermiteControlPoint() {
            m_f1 = 0;
            m_f2 = 0;
            m_f3 = 0;
            m_f4 = 0;
        }
        QHermiteControlPoint(const QPoint& point) : QPoint(point) {
            m_f1 = 0;
            m_f2 = 0;
            m_f3 = 0;
            m_f4 = 0;
        }
        inline const float f1() const { return m_f1; }
        inline const float f2() const { return m_f2; }
        inline const float f3() const { return m_f3; }
        inline const float f4() const { return m_f4; }
        
    protected:
        friend class HermiteCurve;

        // values of M.X for the curve beginning in this point
        float m_f1;
        float m_f2;
        float m_f3;
        float m_f4;
};

class HermiteCurve {
    public:
        HermiteCurve();
        HermiteCurve(const HermiteCurve& other);
        HermiteCurve(int xDimension);
        ~HermiteCurve();

        HermiteCurve& operator=(const HermiteCurve& other);

        void setFloatMax(double max);
        void setIntMax(unsigned long max);

        void update();

        std::size_t size() const;
        void insert(int pos, const QHermiteControlPoint& point);
        QHermiteControlPoint& operator[](std::size_t n);
        const QHermiteControlPoint& operator[](std::size_t n) const;
        void removeAt(std::size_t n);

        const std::size_t findX0(int x) const;

        const uint8_t getY(uint8_t x) const;
        template <typename T>
        const T getY(T x) const;
        const float getY(float x) const;
        const double getY(double x) const;
    private:
        // directly addressed table used to obtain the index of the control point in the m_ctrlPoints
        int* m_ctrlPointLUT;
        std::size_t m_ctrlPointLutSize;

        QVector<QHermiteControlPoint> m_ctrlPoints;
        std::size_t m_ctrlPointsSize;

        // the factor used to normalize values to [0,1]
        int m_xDimension;
        float fscaleFactor;
        double dscaleFactor;
        float fnormalizeFactor;
        double dnormalizeFactor;
        unsigned long m_max;

        // returns the value for (M_h * X)
        // ie. the the value for hermite functions with given parameters
        inline void hermite(float y0, float y1, float dy0, float dy1, QHermiteControlPoint& point);
};

template <typename T>
const T HermiteCurve::getY(T x) const {
    if (m_ctrlPointsSize == 2) {
        double slope = (double)(m_ctrlPoints[1].y() - m_ctrlPoints[0].y()) / (double)(m_ctrlPoints[1].x() - m_ctrlPoints[0].x());
        return ((x * dscaleFactor - m_ctrlPoints[0].x()) * slope + m_ctrlPoints[0].y()) * dnormalizeFactor;
    }
    else {
        double scaledX = dscaleFactor * x;
        std::size_t x0pos = findX0(scaledX);
        QHermiteControlPoint x0 = m_ctrlPoints[x0pos];
        QHermiteControlPoint x1 = m_ctrlPoints[x0pos+1];

        double u = (double)(scaledX - x0.x()) / (double)(x1.x() - x0.x());
        double u2 = u * u;
        double u3 = u2 * u;

        return (u3 * x0.f1() + u2 * x0.f2() + u * x0.f3() + x0.f4()) * dnormalizeFactor;
    }
}

#endif // HERMITECURVE_H