convert_curve.h

#pragma once
 
#include <array>
 
#include "bezier.h"
#include "hermite.h"
 
namespace cgv {
namespace math {
 
template<typename T, typename S = T>
static std::array<T, 5> split_hermite_to_quadratic_beziers(const hermite_node<T>& n0, const hermite_node<T>& n1) {
    std::array<T, 5> bez;
    bez[0] = n0.val;
    bez[1] = n0.val + n0.tan * S(0.2667);
    auto h = n1.val - n1.tan * S(0.2667);
    bez[2] = (bez[1] + h) * S(0.5);
    bez[3] = h;
    bez[4] = n1.val;
    return bez;
}
 
template<typename T, typename S = T>
static std::array<T, 4> hermite_to_cubic_bezier(const hermite_node<T>& n0, const hermite_node<T>& n1) {
    return {
        n0.val,
        n0.val + n0.tan / S(3),
        n1.val - n1.tan / S(3),
        n1.val
    };
}
 
template<typename T, typename S = T>
static std::pair<hermite_node<T>, hermite_node<T>> cubic_bezier_to_hermite(const T& p0, const T& p1, const T& p2, const T& p3) {
    T t0 = S(3) * (p1 - p0);
    T t1 = S(3) * (p3 - p2);
    return { { p0, t0 }, { p3, t1 } };
}
 
template<typename T, typename S = T>
static std::array<T, 4> cubic_basis_to_bezier(const T& b0, const T& b1, const T& b2, const T& b3) {
    constexpr S one_over_three = S(1) / S(3);
    constexpr S one_over_six = S(1) / S(6);
    T p0 = one_over_six * (b0 + S(4) * b1 + b2);
    T p1 = one_over_three * (S(2) * b1 + b2);
    T p2 = one_over_three * (b1 + S(2) * b2);
    T p3 = one_over_six * (b1 + S(4) * b2 + b3);
    return { p0, p1, p2, p3 };
}
 
} // namespace math
} // namespace cgv