curve.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_MATH_CURVE_1107121519_HPP
#define OGLPLUS_MATH_CURVE_1107121519_HPP

#include <oglplus/math/vector.hpp>
#include <oglplus/math/compile_time.hpp>

#include <vector>
#include <array>
#include <cmath>
#include <cassert>

namespace oglplus {


template <typename Type, typename Parameter, unsigned Order>
class BezierCurves
{
private:
    ::std::vector<Type> _points;
    bool _connected;
public:
    static bool Connected(const ::std::vector<Type>& points)
    {
        return ((points.size() - 1) % Order) == 0;
    }

    bool Connected(void) const
    {
        return _connected;
    }

    static bool Separated(const ::std::vector<Type>& points)
    {
        return (points.size() % (Order+1)) == 0;
    }

    bool Separated(void) const
    {
        return !_connected;
    }

    static bool PointsOk(const ::std::vector<Type>& points)
    {
        if(points.empty()) return false;
        return (Connected(points) || Separated(points));
    }


    BezierCurves(::std::vector<Type>&& points)
     : _points(std::move(points))
     , _connected(Connected(_points))
    {
        assert(PointsOk(_points));
    }


    BezierCurves(::std::vector<Type>&& points, bool connected)
     : _points(std::move(points))
     , _connected(connected)
    {
        assert(PointsOk(_points));
        assert(Connected(_points) == _connected);
    }


    BezierCurves(const ::std::vector<Type>& points)
     : _points(points)
     , _connected(Connected(_points))
    {
        assert(PointsOk(_points));
    }


    BezierCurves(const ::std::vector<Type>& points, bool connected)
     : _points(points)
     , _connected(connected)
    {
        assert(PointsOk(_points));
        assert(Connected(_points) == _connected);
    }

    template <std::size_t N>
    BezierCurves(const ::std::array<Type, N>& points)
     : _points(points.begin(), points.end())
     , _connected(Connected(_points))
    {
        assert(PointsOk(_points));
    }

    template <std::size_t N>
    BezierCurves(const ::std::array<Type, N>& points, bool connected)
     : _points(points.begin(), points.end())
     , _connected(connected)
    {
        assert(PointsOk(_points));
        assert(Connected(_points) == _connected);
    }

    unsigned SegmentStep(void) const
    {
        assert(PointsOk(_points));

        if(_connected) return Order;
        else return Order+1;
    }

    unsigned SegmentCount(void) const
    {
        assert(PointsOk(_points));

        if(_connected) return (_points.size() - 1) / Order;
        else return _points.size() / (Order+1);
    }

    const ::std::vector<Type>& ControlPoints(void) const
    {
        return _points;
    }

    static Parameter Wrap(Parameter t)
    {
        const Parameter zero(0);
        const Parameter one(1);
        if(t < zero) t += ::std::floor(::std::fabs(t))+one;
        else if(t > one) t -= ::std::floor(t);
        assert(t >= zero && t <= one);
        return t;
    }

    Type Position01(Parameter t) const
    {
        const Parameter zero(0);
        const Parameter one(1);

        if(t == one) t = zero;
        assert(t >= zero && t < one);

        Parameter toffs = t*SegmentCount();

        unsigned poffs = unsigned(toffs) * SegmentStep();

        assert(poffs < _points.size() - Order);
        Parameter t_sub = toffs - ::std::floor(toffs);
        return math::Bezier<Type, Parameter, Order>::Position(
            _points.data() + poffs,
            _points.size() - poffs,
            t_sub
        );
    }

    Type Position(Parameter t) const
    {
        return Position01(Wrap(t));
    }

    void Approximate(std::vector<Type>& dest, unsigned n) const
    {
        unsigned sstep = SegmentStep();
        unsigned s = SegmentCount();

        dest.resize(s*n+1);

        auto p = dest.begin();
        const Parameter t_step = Parameter(1)/n;

        for(unsigned i=0; i!=s; ++i)
        {
            unsigned poffs = i*sstep;
            Parameter t_sub = Parameter(0);
            const Type* data = _points.data() + poffs;
            unsigned size = _points.size() - poffs;
            for(unsigned j=0; j!=n; ++j)
            {
                typedef math::Bezier<Type, Parameter, Order> b;
                assert(p != dest.end());
                *p = Type(b::Position(data, size, t_sub));
                ++p;

                t_sub += t_step;
            }
        }
        assert(p != dest.end());
        *p = _points.back();
        ++p;
        assert(p == dest.end());
    }

    ::std::vector<Type> Approximate(unsigned n) const
    {
        ::std::vector<Type> result;
        Approximate(result, n);
        return result;
    }

    BezierCurves<Type, Parameter, Order-1> Derivative(void) const
    {
        unsigned sstep = SegmentStep();
        unsigned s = SegmentCount();

        ::std::vector<Type> new_points(s * Order);
        auto p = new_points.begin();

        for(unsigned i=0; i!=s; ++i)
        {
            for(unsigned j=0; j!=Order; ++j)
            {
                unsigned k = i*sstep+j;
                assert(p != new_points.end());
                *p = (_points[k+1] - _points[k]) * Order;
                ++p;
            }
        }
        assert(p == new_points.end());

        return BezierCurves<Type, Parameter, Order-1>(
            std::move(new_points),
            false
        );
    }
};


template <typename Type, typename Parameter>
class CubicBezierLoop
 : public BezierCurves<Type, Parameter, 3>
{
private:
    template <typename StdRange>
    static std::vector<Type> _make_cpoints(
        const StdRange& points,
        Parameter r
    )
    {
        std::size_t i = 0, n = points.size();
        assert(n != 0);
        std::vector<Type> result(n * 3 + 1);
        auto ir = result.begin();
        while(i != n)
        {
            unsigned a = (n+i-1)%n;
            unsigned b = i;
            unsigned c = (i+1)%n;
            unsigned d = (i+2)%n;
            assert(ir != result.end());
            *ir = points[b];
            ++ir;
            assert(ir != result.end());
            *ir = Type(points[b] + (points[c] - points[a])*r);
            ++ir;
            assert(ir != result.end());
            *ir = Type(points[c] + (points[b] - points[d])*r);
            ++ir;
            ++i;
        }
        assert(ir != result.end());
        *ir = points[0]; ++ir;
        assert(ir == result.end());
        return result;
    }
public:
    CubicBezierLoop(
        const ::std::vector<Type>& points,
        Parameter r = Parameter(1)/Parameter(3)
    ): BezierCurves<Type, Parameter, 3>(_make_cpoints(points, r))
    { }

    template <std::size_t N>
    CubicBezierLoop(
        const ::std::array<Type, N>& points,
        Parameter r = Parameter(1)/Parameter(3)
    ): BezierCurves<Type, Parameter, 3>(_make_cpoints(points, r))
    { }
};

} // namespace oglplus

#endif // include guard