kicad/thirdparty/tinyspline_lib/tinysplinecxx.cxx

#define TINYSPLINE_EXPORT
#include "tinysplinecxx.h"

#include <stdlib.h>
#include <cstring>
#include <stdexcept>
#include <cstdio>
#include <sstream>

/* Suppress some useless MSVC warnings. */
#ifdef _MSC_VER
#pragma warning(push)
/* address of dllimport */
#pragma warning(disable:4232)
/* binding rvalues to non-const references */
#pragma warning(disable:4350)
/* unreferenced inline function */
#pragma warning(disable:4514)
/* function not inlined */
#pragma warning(disable:4710)
/* byte padding */
#pragma warning(disable:4820)
/* meaningless deprecation */
#pragma warning(disable:4996)
/* Spectre mitigation */
#pragma warning(disable:5045)
#endif



/*! @name Swig Type Mapping
 *
 * See tinysplinecxx.h for more details.
 *
 * @{
 */
#ifdef SWIG
#define std_real_vector_init(var) \
	std_real_vector_out var = new std::vector<tinyspline::real>
#define std_real_vector_read(var) var->
#else
#define std_real_vector_init(var) \
	std_real_vector_out var
#define std_real_vector_read(var) var.
#endif
/*! @} */



/*! @name Vec2
 *
 * @{
 */
tinyspline::Vec2::Vec2()
{
	const real v = (real) 0.0;
	ts_vec2_init(m_vals, v, v);
}

tinyspline::Vec2::Vec2(real x,
                       real y)
{
	ts_vec2_init(m_vals, x, y);
}

tinyspline::Vec2
tinyspline::Vec2::operator+(const Vec2 &other)
{
	return add(other);
}

tinyspline::Vec2
tinyspline::Vec2::operator-(const Vec2 &other)
{
	return subtract(other);
}

tinyspline::Vec2
tinyspline::Vec2::operator*(real scalar)
{
	return multiply(scalar);
}

tinyspline::real
tinyspline::Vec2::x() const
{
	return m_vals[0];
}

void
tinyspline::Vec2::setX(real val)
{
	m_vals[0] = val;
}

tinyspline::real
tinyspline::Vec2::y() const
{
	return m_vals[1];
}

void
tinyspline::Vec2::setY(real val)
{
	m_vals[1] = val;
}

std::vector<tinyspline::real>
tinyspline::Vec2::values() const
{
	return std::vector<real>({ x(), y() });
}

tinyspline::Vec2
tinyspline::Vec2::add(const Vec2 &other) const
{
	Vec2 vec;
	ts_vec_add(m_vals, other.m_vals, 2, vec.m_vals);
	return vec;
}

tinyspline::Vec2
tinyspline::Vec2::subtract(const Vec2 &other) const
{
	Vec2 vec;
	ts_vec_sub(m_vals, other.m_vals, 2, vec.m_vals);
	return vec;
}

tinyspline::Vec2
tinyspline::Vec2::multiply(real scalar) const
{
	Vec2 vec;
	ts_vec_mul(m_vals, 2, scalar, vec.m_vals);
	return vec;
}

tinyspline::Vec2
tinyspline::Vec2::normalize() const
{
	Vec2 vec;
	ts_vec_norm(m_vals, 2, vec.m_vals);
	return vec;
}

tinyspline::Vec2
tinyspline::Vec2::norm() const
{
	return normalize();
}

tinyspline::real
tinyspline::Vec2::magnitude() const
{
	return ts_vec_mag(m_vals, 2);
}

tinyspline::real
tinyspline::Vec2::dot(const Vec2 &other) const
{
	return ts_vec_dot(m_vals, other.m_vals, 2);
}

tinyspline::real
tinyspline::Vec2::angle(const Vec2 &other) const
{
	real buf[4];
	return ts_vec_angle(m_vals, other.m_vals, buf, 2);
}

tinyspline::real
tinyspline::Vec2::distance(const Vec2 &other) const
{
	return ts_distance(m_vals, other.m_vals, 2);
}

std::string
tinyspline::Vec2::toString() const
{
	std::ostringstream oss;
	oss << "Vec2{"
	    << "x: " << x()
	    << ", y: " << y()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name Vec3
 *
 * @{
 */
tinyspline::Vec3::Vec3()
{
	const real v = (real) 0.0;
	ts_vec3_init(m_vals, v, v, v);
}

tinyspline::Vec3::Vec3(real x,
                       real y,
                       real z)
{
	ts_vec3_init(m_vals, x, y, z);
}

tinyspline::Vec3
tinyspline::Vec3::operator+(const Vec3 &other)
{
	return add(other);
}

tinyspline::Vec3
tinyspline::Vec3::operator-(const Vec3 &other)
{
	return subtract(other);
}

tinyspline::Vec3
tinyspline::Vec3::operator*(real scalar)
{
	return multiply(scalar);
}

tinyspline::real
tinyspline::Vec3::x() const
{
	return m_vals[0];
}

void
tinyspline::Vec3::setX(real val)
{
	m_vals[0] = val;
}

tinyspline::real
tinyspline::Vec3::y() const
{
	return m_vals[1];
}

void
tinyspline::Vec3::setY(real val)
{
	m_vals[1] = val;
}

tinyspline::real
tinyspline::Vec3::z() const
{
	return m_vals[2];
}

void
tinyspline::Vec3::setZ(real val)
{
	m_vals[2] = val;
}

std::vector<tinyspline::real>
tinyspline::Vec3::values() const
{
	return std::vector<real>({ x(), y(), z() });
}

tinyspline::Vec3
tinyspline::Vec3::add(const Vec3 &other) const
{
	Vec3 vec;
	ts_vec_add(m_vals, other.m_vals, 3, vec.m_vals);
	return vec;
}

tinyspline::Vec3
tinyspline::Vec3::subtract(const Vec3 &other) const
{
	Vec3 vec;
	ts_vec_sub(m_vals, other.m_vals, 3, vec.m_vals);
	return vec;
}

tinyspline::Vec3
tinyspline::Vec3::multiply(real scalar) const
{
	Vec3 vec;
	ts_vec_mul(m_vals, 3, scalar, vec.m_vals);
	return vec;
}

tinyspline::Vec3
tinyspline::Vec3::cross(const Vec3 &other) const
{
	Vec3 vec;
	ts_vec3_cross(m_vals, other.m_vals, vec.m_vals);
	return vec;
}

tinyspline::Vec3
tinyspline::Vec3::normalize() const
{
	Vec3 vec;
	ts_vec_norm(m_vals, 3, vec.m_vals);
	return vec;
}

tinyspline::Vec3
tinyspline::Vec3::norm() const
{
	return normalize();
}

tinyspline::real
tinyspline::Vec3::magnitude() const
{
	return ts_vec_mag(m_vals, 3);
}

tinyspline::real
tinyspline::Vec3::dot(const Vec3 &other) const
{
	return ts_vec_dot(m_vals, other.m_vals, 3);
}

tinyspline::real
tinyspline::Vec3::angle(const Vec3 &other) const
{
	real buf[6];
	return ts_vec_angle(m_vals, other.m_vals, buf, 3);
}

tinyspline::real
tinyspline::Vec3::distance(const Vec3 &other) const
{
	return ts_distance(m_vals, other.m_vals, 3);
}

std::string
tinyspline::Vec3::toString() const
{
	std::ostringstream oss;
	oss << "Vec3{"
	    << "x: " << x()
	    << ", y: " << y()
	    << ", z: " << z()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name Vec4
 *
 * @{
 */
tinyspline::Vec4::Vec4()
{
	const real v = (real) 0.0;
	ts_vec4_init(m_vals, v, v, v, v);
}

tinyspline::Vec4::Vec4(real x,
                       real y,
                       real z,
                       real w)
{
	ts_vec4_init(m_vals, x, y, z, w);
}

tinyspline::Vec4
tinyspline::Vec4::operator+(const Vec4 &other)
{
	return add(other);
}

tinyspline::Vec4
tinyspline::Vec4::operator-(const Vec4 &other)
{
	return subtract(other);
}

tinyspline::Vec4
tinyspline::Vec4::operator*(real scalar)
{
	return multiply(scalar);
}

tinyspline::real
tinyspline::Vec4::x() const
{
	return m_vals[0];
}

void
tinyspline::Vec4::setX(real val)
{
	m_vals[0] = val;
}

tinyspline::real
tinyspline::Vec4::y() const
{
	return m_vals[1];
}

void
tinyspline::Vec4::setY(real val)
{
	m_vals[1] = val;
}

tinyspline::real
tinyspline::Vec4::z() const
{
	return m_vals[2];
}

void
tinyspline::Vec4::setZ(real val)
{
	m_vals[2] = val;
}

tinyspline::real
tinyspline::Vec4::w() const
{
	return m_vals[3];
}

void
tinyspline::Vec4::setW(real val)
{
	m_vals[3] = val;
}

std::vector<tinyspline::real>
tinyspline::Vec4::values() const
{
	return std::vector<real>({ x(), y(), z(), w() });
}

tinyspline::Vec4
tinyspline::Vec4::add(const Vec4 &other) const
{
	Vec4 vec;
	ts_vec_add(m_vals, other.m_vals, 4, vec.m_vals);
	return vec;
}

tinyspline::Vec4
tinyspline::Vec4::subtract(const Vec4 &other) const
{
	Vec4 vec;
	ts_vec_sub(m_vals, other.m_vals, 4, vec.m_vals);
	return vec;
}

tinyspline::Vec4
tinyspline::Vec4::multiply(real scalar) const
{
	Vec4 vec;
	ts_vec_mul(m_vals, 4, scalar, vec.m_vals);
	return vec;
}

tinyspline::Vec4
tinyspline::Vec4::normalize() const
{
	Vec4 vec;
	ts_vec_norm(m_vals, 4, vec.m_vals);
	return vec;
}

tinyspline::Vec4
tinyspline::Vec4::norm() const
{
	return normalize();
}

tinyspline::real
tinyspline::Vec4::magnitude() const
{
	return ts_vec_mag(m_vals, 4);
}

tinyspline::real
tinyspline::Vec4::dot(const Vec4 &other) const
{
	return ts_vec_dot(m_vals, other.m_vals, 4);
}

tinyspline::real
tinyspline::Vec4::angle(const Vec4 &other) const
{
	real buf[8];
	return ts_vec_angle(m_vals, other.m_vals, buf, 4);
}

tinyspline::real
tinyspline::Vec4::distance(const Vec4 &other) const
{
	return ts_distance(m_vals, other.m_vals, 4);
}

std::string
tinyspline::Vec4::toString() const
{
	std::ostringstream oss;
	oss << "Vec4{"
	    << "x: " << x()
	    << ", y: " << y()
	    << ", z: " << z()
	    << ", w: " << w()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name Frame
 *
 * @{
 */
tinyspline::Frame::Frame(Vec3 &position,
                         Vec3 &tangent,
                         Vec3 &normal,
                         Vec3 &binormal)
: m_position(position),
  m_tangent(tangent),
  m_normal(normal),
  m_binormal(binormal)
{}

tinyspline::Vec3
tinyspline::Frame::position() const
{
	return m_position;
}

tinyspline::Vec3
tinyspline::Frame::tangent() const
{
	return m_tangent;
}

tinyspline::Vec3
tinyspline::Frame::normal() const
{
	return m_normal;
}

tinyspline::Vec3
tinyspline::Frame::binormal() const
{
	return m_binormal;
}

std::string
tinyspline::Frame::toString() const
{
	std::ostringstream oss;
	oss << "Frame{"
	    << "position: " << position().toString()
	    << ", tangent: " << tangent().toString()
	    << ", normal: " << normal().toString()
	    << ", binormal: " << binormal().toString()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name FrameSeq
 *
 * @{
 */
tinyspline::FrameSeq::FrameSeq()
: m_frames(nullptr), m_size(0)
{}

tinyspline::FrameSeq::FrameSeq(tsFrame *frames,
                               size_t len)
: m_frames(frames), m_size(len)
{}

tinyspline::FrameSeq::FrameSeq(const FrameSeq &other)
: m_frames(nullptr), m_size(other.m_size)
{
	m_frames = new tsFrame[m_size];
	std::copy(other.m_frames,
	          other.m_frames + m_size,
	          m_frames);
}

tinyspline::FrameSeq::FrameSeq(FrameSeq &&other)
: m_frames(nullptr), m_size(other.m_size)
{
	m_frames = other.m_frames;
	other.m_frames = nullptr;
	other.m_size = 0;
}

tinyspline::FrameSeq::~FrameSeq()
{
	delete [] m_frames;
	m_size = 0;
}

tinyspline::FrameSeq &
tinyspline::FrameSeq::operator=(const FrameSeq &other)
{
	if (&other != this) {
		tsFrame *data = new tsFrame[other.m_size];
		std::copy(other.m_frames,
		          other.m_frames + other.m_size,
		          data);
		delete [] m_frames;
		m_frames = data;
		m_size = other.m_size;
	}
	return *this;
}

tinyspline::FrameSeq &
tinyspline::FrameSeq::operator=(FrameSeq &&other)
{
	if (&other != this) {
		delete [] m_frames;
		m_frames = other.m_frames;
		m_size = other.m_size;
		other.m_frames = nullptr;
		other.m_size = 0;
	}
	return *this;
}

size_t
tinyspline::FrameSeq::size() const
{
	return m_size;
}

tinyspline::Frame
tinyspline::FrameSeq::at(size_t idx) const
{
	if (idx >= m_size)
		throw std::out_of_range( "idx >= size");
	tsFrame frame = m_frames[idx];
	Vec3 position = Vec3(frame.position[0],
	                     frame.position[1],
	                     frame.position[2]);
	Vec3 tangent = Vec3(frame.tangent[0],
	                    frame.tangent[1],
	                    frame.tangent[2]);
	Vec3 normal = Vec3(frame.normal[0],
	                   frame.normal[1],
	                   frame.normal[2]);
	Vec3 binormal = Vec3(frame.binormal[0],
	                     frame.binormal[1],
	                     frame.binormal[2]);
	return Frame(position, tangent, normal, binormal);
}

std::string
tinyspline::FrameSeq::toString() const
{
	std::ostringstream oss;
	oss << "FrameSeq{"
	    << "frames: " << size()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name Domain
 *
 * @{
 */
tinyspline::Domain::Domain(real min,
                           real max)
: m_min(min), m_max(max)
{}

tinyspline::real
tinyspline::Domain::min() const
{
	return m_min;
}

tinyspline::real
tinyspline::Domain::max() const
{
	return m_max;
}

std::string
tinyspline::Domain::toString() const
{
	std::ostringstream oss;
        oss << "Domain{"
            << "min: " << min()
            << ", max: " << max()
            << "}";
	return oss.str();
}
/*! @} */



/*! @name DeBoorNet
 *
 * @{
 */
tinyspline::DeBoorNet::DeBoorNet(tsDeBoorNet &data)
: net(ts_deboornet_init())
{
	ts_deboornet_move(&data, &net);
}

tinyspline::DeBoorNet::DeBoorNet(const DeBoorNet &other)
: net(ts_deboornet_init())
{
	tsStatus status;
	if (ts_deboornet_copy(&other.net, &net, &status))
		throw std::runtime_error(status.message);
}

tinyspline::DeBoorNet::DeBoorNet(DeBoorNet &&other)
: net(ts_deboornet_init())
{
	ts_deboornet_move(&other.net, &net);
}

tinyspline::DeBoorNet::~DeBoorNet()
{
	ts_deboornet_free(&net);
}

tinyspline::DeBoorNet &
tinyspline::DeBoorNet::operator=(const DeBoorNet &other)
{
	if (&other != this) {
		tsDeBoorNet data = ts_deboornet_init();
		tsStatus status;
		if (ts_deboornet_copy(&other.net, &data, &status))
			throw std::runtime_error(status.message);
		ts_deboornet_free(&net);
		ts_deboornet_move(&data, &net);
	}
	return *this;
}

tinyspline::DeBoorNet &
tinyspline::DeBoorNet::operator=(DeBoorNet && other)
{
	if (&other != this) {
		ts_deboornet_free(&net);
		ts_deboornet_move(&other.net, &net);
	}
	return *this;
}

tinyspline::real
tinyspline::DeBoorNet::knot() const
{
	return ts_deboornet_knot(&net);
}

size_t
tinyspline::DeBoorNet::index() const
{
	return ts_deboornet_index(&net);
}

size_t
tinyspline::DeBoorNet::multiplicity() const
{
	return ts_deboornet_multiplicity(&net);
}

size_t
tinyspline::DeBoorNet::numInsertions() const
{
	return ts_deboornet_num_insertions(&net);
}

size_t
tinyspline::DeBoorNet::dimension() const
{
	return ts_deboornet_dimension(&net);
}

std::vector<tinyspline::real>
tinyspline::DeBoorNet::points() const
{
	const real *points = ts_deboornet_points_ptr(&net);
	size_t len = ts_deboornet_len_points(&net);
	return std::vector<real>(points, points + len);
}

std::vector<tinyspline::real>
tinyspline::DeBoorNet::result() const
{
	const real *result = ts_deboornet_result_ptr(&net);
	size_t len = ts_deboornet_len_result(&net);
	return std::vector<real>(result, result + len);
}

tinyspline::Vec2
tinyspline::DeBoorNet::resultVec2(size_t idx) const
{
	Vec4 vec4 = resultVec4(idx);
	return Vec2(vec4.x(), vec4.y());
}

tinyspline::Vec3
tinyspline::DeBoorNet::resultVec3(size_t idx) const
{
	Vec4 vec4 = resultVec4(idx);
	return Vec3(vec4.x(), vec4.y(), vec4.z());
}

tinyspline::Vec4
tinyspline::DeBoorNet::resultVec4(size_t idx) const
{
	if (idx >= ts_deboornet_num_result(&net))
		throw std::out_of_range( "idx >= num(result)");
	const real *result = ts_deboornet_result_ptr(&net);
	real vals[4];
	ts_vec4_set(vals, result + idx * dimension(), dimension());
	return Vec4(vals[0], vals[1], vals[2], vals[3]);
}

std::string
tinyspline::DeBoorNet::toString() const
{
	std::ostringstream oss;
	oss << "DeBoorNet{"
	    << "knot: " << knot()
	    << ", index: " << index()
	    << ", multiplicity: " << multiplicity()
	    << ", insertions: " << numInsertions()
	    << ", dimension: " << dimension()
	    << ", points: " << ts_deboornet_num_points(&net)
	    << "}";
	return oss.str();
}
/*! @} */



/******************************************************************************
*                                                                             *
* BSpline                                                                     *
*                                                                             *
******************************************************************************/
tinyspline::BSpline::BSpline(tsBSpline &data)
: spline(ts_bspline_init())
{
	ts_bspline_move(&data, &spline);
}

tinyspline::BSpline::BSpline()
: spline(ts_bspline_init())
{
	tsStatus status;
	if (ts_bspline_new_with_control_points(1,
	                                       3,
	                                       0,
	                                       TS_CLAMPED,
	                                       &spline,
	                                       &status,
	                                       0.0, 0.0, 0.0))
		throw std::runtime_error(status.message);
}

tinyspline::BSpline::BSpline(const tinyspline::BSpline &other)
: spline(ts_bspline_init())
{
	tsStatus status;
	if (ts_bspline_copy(&other.spline, &spline, &status))
		throw std::runtime_error(status.message);
}

tinyspline::BSpline::BSpline(BSpline &&other)
: spline(ts_bspline_init())
{
	ts_bspline_move(&other.spline, &spline);
}

tinyspline::BSpline::BSpline(size_t numControlPoints,
                             size_t dimension,
                             size_t degree,
                             Type type)
: spline(ts_bspline_init())
{
	tsBSplineType c_type = TS_CLAMPED;
	switch (type) {
	case Opened:
		c_type = TS_OPENED;
		break;
	case Clamped:
		c_type = TS_CLAMPED;
		break;
	case Beziers:
		c_type = TS_BEZIERS;
		break;
	default:
		throw std::runtime_error("unknown type");
	}
	tsStatus status;
	if (ts_bspline_new(numControlPoints,
	                   dimension,
	                   degree,
	                   c_type,
	                   &spline,
	                   &status))
		throw std::runtime_error(status.message);
}

tinyspline::BSpline::~BSpline()
{
	ts_bspline_free(&spline);
}

tinyspline::BSpline tinyspline::BSpline::interpolateCubicNatural(
	std_real_vector_in points, size_t dimension)
{
	if (dimension == 0)
		throw std::runtime_error("unsupported dimension: 0");
	if (std_real_vector_read(points)size() % dimension != 0)
		throw std::runtime_error("#points % dimension != 0");
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_interpolate_cubic_natural(
			std_real_vector_read(points)data(),
			std_real_vector_read(points)size()/dimension,
			dimension, &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline
tinyspline::BSpline::interpolateCatmullRom(std_real_vector_in points,
                                           size_t dimension,
                                           real alpha,
                                           std::vector<real> *first,
                                           std::vector<real> *last,
                                           real epsilon)
{
	if (dimension == 0)
		throw std::runtime_error("unsupported dimension: 0");
	if (std_real_vector_read(points)size() % dimension != 0)
		throw std::runtime_error("#points % dimension != 0");
	real *fst = nullptr;
	if (first && first->size() >= dimension)
		fst = first->data();
	real *lst = nullptr;
	if (last && last->size() >= dimension)
		lst = last->data();
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_interpolate_catmull_rom(
			std_real_vector_read(points)data(),
			std_real_vector_read(points)size()/dimension,
			dimension, alpha, fst, lst, epsilon, &data,
			&status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::parseJson(std::string json)
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_parse_json(json.c_str(), &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::load(std::string path)
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_load(path.c_str(), &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

bool
tinyspline::BSpline::knotsEqual(real x, real y)
{
	return ts_knots_equal(x, y);
}

tinyspline::BSpline &
tinyspline::BSpline::operator=(const BSpline &other)
{
	if (&other != this) {
		tsBSpline data = ts_bspline_init();
		tsStatus status;
		if (ts_bspline_copy(&other.spline, &data, &status))
			throw std::runtime_error(status.message);
		ts_bspline_free(&spline);
		ts_bspline_move(&data, &spline);
	}
	return *this;
}

tinyspline::BSpline &
tinyspline::BSpline::operator=(BSpline &&other)
{
	if (&other != this) {
		ts_bspline_free(&spline);
		ts_bspline_move(&other.spline, &spline);
	}
	return *this;
}

tinyspline::DeBoorNet tinyspline::BSpline::operator()(tinyspline::real u) const
{
	return eval(u);
}

size_t tinyspline::BSpline::degree() const
{
	return ts_bspline_degree(&spline);
}

size_t tinyspline::BSpline::order() const
{
	return ts_bspline_order(&spline);
}

size_t tinyspline::BSpline::dimension() const
{
	return ts_bspline_dimension(&spline);
}

std::vector<tinyspline::real>
tinyspline::BSpline::controlPoints() const
{
	const real *ctrlps = ts_bspline_control_points_ptr(&spline);
	const size_t len = ts_bspline_len_control_points(&spline);
	return std::vector<real>(ctrlps, ctrlps + len);
}

tinyspline::Vec2
tinyspline::BSpline::controlPointVec2At(size_t idx) const
{
	const Vec4 vec4 = controlPointVec4At(idx);
	return Vec2(vec4.x(), vec4.y());
}

tinyspline::Vec3
tinyspline::BSpline::controlPointVec3At(size_t idx) const
{
	const Vec4 vec4 = controlPointVec4At(idx);
	return Vec3(vec4.x(), vec4.y(), vec4.z());
}

tinyspline::Vec4
tinyspline::BSpline::controlPointVec4At(size_t idx) const
{
	const real *ctrlp;
	tsStatus status;
	if (ts_bspline_control_point_at_ptr(&spline,
	                                    idx,
	                                    &ctrlp,
	                                    &status))
		throw std::runtime_error(status.message);
	real vals[4];
	ts_vec4_set(vals, ctrlp, dimension());
	return Vec4(vals[0], vals[1], vals[2], vals[3]);
}

std::vector<tinyspline::real>
tinyspline::BSpline::knots() const
{
	const real *knots = ts_bspline_knots_ptr(&spline);
	size_t num = ts_bspline_num_knots(&spline);
	return std::vector<real>(knots, knots + num);
}

tinyspline::real tinyspline::BSpline::knotAt(size_t index) const
{
	real knot;
	tsStatus status;
	if (ts_bspline_knot_at(&spline, index, &knot, &status))
		throw std::runtime_error(status.message);
	return knot;
}

size_t tinyspline::BSpline::numControlPoints() const
{
	return ts_bspline_num_control_points(&spline);
}

tinyspline::DeBoorNet tinyspline::BSpline::eval(tinyspline::real u) const
{
	tsDeBoorNet net = ts_deboornet_init();
	tsStatus status;
	if (ts_bspline_eval(&spline, u, &net, &status))
		throw std::runtime_error(status.message);
	return tinyspline::DeBoorNet(net);
}

tinyspline::std_real_vector_out
tinyspline::BSpline::evalAll(std_real_vector_in knots) const
{
	const size_t num_knots = std_real_vector_read(knots)size();
	const real *knots_ptr = std_real_vector_read(knots)data();
	tinyspline::real *points;
	tsStatus status;
	if (ts_bspline_eval_all(&spline,
	                        knots_ptr,
	                        num_knots,
	                        &points,
	                        &status)) {
		throw std::runtime_error(status.message);
	}
	real *first = points;
	real *last = first + num_knots * dimension();
	std_real_vector_init(vec)(first, last);
	std::free(points);
	return vec;
}

tinyspline::std_real_vector_out
tinyspline::BSpline::sample(size_t num) const
{
	tinyspline::real *points;
	size_t actualNum;
	tsStatus status;
	if (ts_bspline_sample(&spline,
	                      num,
	                      &points,
	                      &actualNum,
	                      &status)) {
		throw std::runtime_error(status.message);
	}
	real *first = points;
	real *last = first + actualNum * dimension();
	std_real_vector_init(vec)(first, last);
	std::free(points);
	return vec;
}

tinyspline::DeBoorNet tinyspline::BSpline::bisect(real value,
                                                  real epsilon,
                                                  bool persnickety,
                                                  size_t index,
                                                  bool ascending,
                                                  size_t maxIter) const
{
	tsDeBoorNet net = ts_deboornet_init();
	tsStatus status;
	if (ts_bspline_bisect(&spline,
	                      value,
	                      epsilon,
	                      persnickety,
	                      index,
	                      ascending,
	                      maxIter,
	                      &net,
	                      &status))
		throw std::runtime_error(status.message);
	return DeBoorNet(net);
}

tinyspline::Domain tinyspline::BSpline::domain() const
{
	real min, max;
	ts_bspline_domain(&spline, &min, &max);
	return Domain(min, max);
}

bool tinyspline::BSpline::isClosed(tinyspline::real epsilon) const
{
	int closed = 0;
	tsStatus status;
	if (ts_bspline_is_closed(&spline, epsilon, &closed, &status))
		throw std::runtime_error(status.message);
	return closed == 1;
}

tinyspline::FrameSeq
tinyspline::BSpline::computeRMF(std_real_vector_in knots,
                                tinyspline::Vec3 *firstNormal) const
{
	tsStatus status;
	size_t num = std_real_vector_read(knots)size();
	const real *knots_ptr = std_real_vector_read(knots)data();
	tsFrame *frames = new tsFrame[num];
	if (firstNormal && num > 0) {
		ts_vec3_init(frames[0].normal,
		             firstNormal->x(),
		             firstNormal->y(),
		             firstNormal->z());
	}
	if (ts_bspline_compute_rmf(&spline,
	                           knots_ptr,
	                           num,
	                           firstNormal != nullptr,
	                           frames,
	                           &status))
		throw std::runtime_error(status.message);
	FrameSeq seq = FrameSeq(frames, num);
	return seq;
}


tinyspline::BSpline
tinyspline::BSpline::subSpline(real knot0, real knot1) const
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_sub_spline(&spline,
	                          knot0,
	                          knot1,
	                          &data,
	                          &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::std_real_vector_out
tinyspline::BSpline::uniformKnotSeq(size_t num) const
{
	std_real_vector_init(knots)(num);
	real *knots_ptr = std_real_vector_read(knots)data();
	ts_bspline_uniform_knot_seq(&spline, num, knots_ptr);
	return knots;
}

tinyspline::std_real_vector_out
tinyspline::BSpline::equidistantKnotSeq(size_t num,
                                        size_t numSamples) const
{
	tsStatus status;
	std_real_vector_init(knots)(num);
	real *knots_ptr = std_real_vector_read(knots)data();
	if (ts_bspline_equidistant_knot_seq(&spline,
	                                    num,
	                                    knots_ptr,
	                                    numSamples,
	                                    &status))
		throw std::runtime_error(status.message);
	return knots;
}

tinyspline::ChordLengths
tinyspline::BSpline::chordLengths(std_real_vector_in knots) const
{
	tsStatus status;
	size_t num = std_real_vector_read(knots)size();
	real *knotsArr = new real[num];
	real *lengths = new real[num];
	std::copy(std_real_vector_read(knots)begin(),
	          std_real_vector_read(knots)end(),
	          knotsArr);
	if (ts_bspline_chord_lengths(&spline,
	                             knotsArr,
	                             num,
	                             lengths,
	                             &status))
		throw std::runtime_error(status.message);
	return ChordLengths(*this, knotsArr, lengths, num);
}

tinyspline::ChordLengths
tinyspline::BSpline::chordLengths(size_t numSamples) const
{
	return chordLengths(uniformKnotSeq(numSamples));
}

std::string tinyspline::BSpline::toJson() const
{
	char *json;
	tsStatus status;
	if (ts_bspline_to_json(&spline, &json, &status))
		throw std::runtime_error(status.message);
	std::string string(json);
	std::free(json);
	return string;
}

void tinyspline::BSpline::save(std::string path) const
{
	tsStatus status;
	if (ts_bspline_save(&spline, path.c_str(), &status))
		throw std::runtime_error(status.message);
}

void tinyspline::BSpline::setControlPoints(
	const std::vector<tinyspline::real> &ctrlp)
{
	size_t expected = ts_bspline_len_control_points(&spline);
	size_t actual = ctrlp.size();
	if (expected != actual) {
		std::ostringstream oss;
		oss << "Expected size: " << expected
		    << ", Actual size: " << actual;
		throw std::runtime_error(oss.str());
	}
	tsStatus status;
	if (ts_bspline_set_control_points(&spline, ctrlp.data(), &status))
		throw std::runtime_error(status.message);
}

void
tinyspline::BSpline::setControlPointVec2At(size_t idx, Vec2 &cp)
{
	Vec4 vec4(cp.x(), cp.y(), (real) 0.0, (real) 0.0);
	setControlPointVec4At(idx, vec4);
}

void
tinyspline::BSpline::setControlPointVec3At(size_t idx, Vec3 &cp)
{
	Vec4 vec4(cp.x(), cp.y(), cp.z(), (real) 0.0);
	setControlPointVec4At(idx, vec4);
}

void
tinyspline::BSpline::setControlPointVec4At(size_t idx, Vec4 &cp)
{
	std::vector<real> vals(dimension());
	for (size_t i = 0; i < vals.size(); i++)
		vals[i] = (real) 0.0;
	if (vals.size() >= 4) vals[3] = cp.w();
	if (vals.size() >= 3) vals[2] = cp.z();
	if (vals.size() >= 2) vals[1] = cp.y();
	if (vals.size() >= 1) vals[0] = cp.x();
	tsStatus status;
	if (ts_bspline_set_control_point_at(&spline,
	                                    idx,
	                                    vals.data(),
	                                    &status))
		throw std::runtime_error(status.message);
}

void
tinyspline::BSpline::setKnots(const std::vector<real> &knots)
{
	size_t expected = ts_bspline_num_knots(&spline);
	size_t actual = knots.size();
	if (expected != actual) {
		std::ostringstream oss;
		oss << "Expected size: " << expected
		    << ", Actual size: " << actual;
		throw std::runtime_error(oss.str());
	}
	tsStatus status;
	if (ts_bspline_set_knots(&spline,
	                         knots.data(),
	                         &status))
		throw std::runtime_error(status.message);
}

void tinyspline::BSpline::setKnotAt(size_t index, tinyspline::real knot)
{
	tsStatus status;
	if (ts_bspline_set_knot_at(&spline, index, knot, &status))
		throw std::runtime_error(status.message);
}

tinyspline::BSpline tinyspline::BSpline::insertKnot(tinyspline::real u,
	size_t n) const
{
	tsBSpline data = ts_bspline_init();
	size_t k;
	tsStatus status;
	if (ts_bspline_insert_knot(&spline, u, n, &data, &k, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::split(tinyspline::real u) const
{
	tsBSpline data = ts_bspline_init();
	size_t k;
	tsStatus status;
	if (ts_bspline_split(&spline, u, &data, &k, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::tension(
	tinyspline::real tension) const
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_tension(&spline, tension, &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::toBeziers() const
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_to_beziers(&spline, &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::derive(size_t n, real epsilon) const
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_derive(&spline, n, epsilon, &data, &status))
		throw std::runtime_error(status.message);
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::elevateDegree(
	size_t amount, real epsilon) const
{
	tsBSpline data = ts_bspline_init();
	tsStatus status;
	if (ts_bspline_elevate_degree(&spline, amount, epsilon,
		&data, &status)) {
		throw std::runtime_error(status.message);
	}
	return BSpline(data);
}

tinyspline::BSpline tinyspline::BSpline::alignWith(
	const BSpline &other, BSpline &otherAligned, real epsilon) const
{
	tsBSpline data = ts_bspline_init();
	tsBSpline deleteIf_Other_And_OtherAligned_AreDifferent =
		otherAligned.spline;
	tsStatus status;
	if (ts_bspline_align(&spline, &other.spline, epsilon, &data,
		&otherAligned.spline, &status)) {
		throw std::runtime_error(status.message);
	}
	if (&other != &otherAligned)
		ts_bspline_free(&deleteIf_Other_And_OtherAligned_AreDifferent);
	return BSpline(data);
}

tinyspline::Morphism tinyspline::BSpline::morphTo(
	const BSpline &other, real epsilon) const
{
	return Morphism(*this, other, epsilon);
}

std::string tinyspline::BSpline::toString() const
{
	Domain d = domain();
	std::ostringstream oss;
	oss << "BSpline{"
	    << "dimension: " << dimension()
	    << ", degree: " << degree()
	    << ", domain: [" << d.min() << ", " << d.max() << "]"
	    << ", control points: " << numControlPoints()
	    << ", knots: " << ts_bspline_num_knots(&spline)
	    << "}";
	return oss.str();
}



/*! @name Morphism
 *
 * @{
 */
tinyspline::Morphism::Morphism(const BSpline &origin,
			       const BSpline &target,
			       real epsilon)
: m_origin(origin), m_target(target), m_epsilon(epsilon)
{
	m_originAligned = origin.alignWith(target, m_targetAligned, epsilon);
	// Make buffer compatible by copying one of the aligned splines.
	m_buffer = m_originAligned;
}

tinyspline::BSpline
tinyspline::Morphism::eval(real t)
{
	tsStatus status;
	if (t <= 0) return m_origin;
	if (t >= 1) return m_target;
	if (ts_bspline_morph(&m_originAligned.spline,
			     &m_targetAligned.spline,
			     t, m_epsilon,
			     &m_buffer.spline, &status)) {
		throw std::runtime_error(status.message);
	}
	return m_buffer;
}

tinyspline::BSpline
tinyspline::Morphism::origin() const
{
	return m_origin;
}

tinyspline::BSpline
tinyspline::Morphism::target() const
{
	return m_target;
}

tinyspline::real
tinyspline::Morphism::epsilon() const
{
	return m_epsilon;
}

tinyspline::BSpline
tinyspline::Morphism::operator()(real t)
{
	return eval(t);
}

std::string tinyspline::Morphism::toString() const
{
	std::ostringstream oss;
	oss << "Morphism{"
	    << "buffer: " << m_buffer.toString()
	    << ", epsilon: " << epsilon()
	    << "}";
	return oss.str();
}
/*! @} */



/*! @name ChordLenghts
 * @{
 */
tinyspline::ChordLengths::ChordLengths()
: m_spline(),
  m_knots(nullptr),
  m_chordLengths(nullptr),
  m_size(0)
{}

tinyspline::ChordLengths::ChordLengths(const BSpline &spline,
                                       real *knots,
                                       real *chordLengths,
                                       size_t size)
: m_spline(spline),
  m_knots(knots),
  m_chordLengths(chordLengths),
  m_size(size)
{}

tinyspline::ChordLengths::ChordLengths(const ChordLengths &other)
: m_spline(other.m_spline),
  m_knots(nullptr),
  m_chordLengths(nullptr),
  m_size(other.m_size)
{
	m_knots = new real[m_size];
	std::copy(other.m_knots,
	          other.m_knots + m_size,
	          m_knots);
	m_chordLengths = new real[m_size];
	std::copy(other.m_chordLengths,
	          other.m_chordLengths + m_size,
	          m_chordLengths);
}

tinyspline::ChordLengths::ChordLengths(ChordLengths &&other)
: m_spline(),
  m_knots(nullptr),
  m_chordLengths(nullptr),
  m_size(0)
{
	*this = std::move(other);
}

tinyspline::ChordLengths::~ChordLengths()
{
	delete [] m_knots;
	delete [] m_chordLengths;
	m_size = 0;
}

tinyspline::ChordLengths &
tinyspline::ChordLengths::operator=(const ChordLengths &other)
{
	if (&other != this) {
		real *knots = new real[other.m_size];
		std::copy(other.m_knots,
		          other.m_knots + other.m_size,
		          knots);
		real *chordLengths = new real[other.m_size];
		std::copy(other.m_chordLengths,
		          other.m_chordLengths + other.m_size,
		          chordLengths);
		delete [] m_knots;
		delete [] m_chordLengths;
		m_spline = other.m_spline;
		m_knots = knots;
		m_chordLengths = chordLengths;
		m_size = other.m_size;
	}
	return *this;
}

tinyspline::ChordLengths &
tinyspline::ChordLengths::operator=(ChordLengths &&other)
{
	if (&other != this) {
		delete [] m_knots;
		delete [] m_chordLengths;
		m_spline = other.m_spline;
		m_knots = other.m_knots;
		m_chordLengths = other.m_chordLengths;
		m_size = other.m_size;
		other.m_spline = BSpline();
		other.m_knots = nullptr;
		other.m_chordLengths = nullptr;
		other.m_size = 0;
	}
	return *this;
}

tinyspline::BSpline
tinyspline::ChordLengths::spline() const
{
	return m_spline;
}

std::vector<tinyspline::real>
tinyspline::ChordLengths::knots() const
{
	return std::vector<real>(m_knots,
	                         m_knots + m_size);
}

std::vector<tinyspline::real>
tinyspline::ChordLengths::values() const
{
	return std::vector<real>(m_chordLengths,
	                         m_chordLengths + m_size);
}

size_t
tinyspline::ChordLengths::size() const
{
	return m_size;
}

tinyspline::real
tinyspline::ChordLengths::arcLength() const
{
	return m_size == 0 ? 0 : m_chordLengths[m_size - 1];
}

tinyspline::real
tinyspline::ChordLengths::lengthToKnot(real len) const
{
	tsStatus status;
	real knot;
	if (ts_chord_lengths_length_to_knot(m_knots,
	                               m_chordLengths,
	                               m_size,
	                               len,
	                               &knot,
	                               &status))
		throw std::runtime_error(status.message);
	return knot;
}

tinyspline::real
tinyspline::ChordLengths::tToKnot(real t) const
{
	tsStatus status;
	real knot;
	if (ts_chord_lengths_t_to_knot(m_knots,
	                               m_chordLengths,
	                               m_size,
	                               t,
	                               &knot,
	                               &status))
		throw std::runtime_error(status.message);
	return knot;
}

std::string
tinyspline::ChordLengths::toString() const
{
	std::ostringstream oss;
	oss << "ChordLengths{"
	    << "spline: " << m_spline.toString()
	    << ", values: " << m_size
	    << "}";
	return oss.str();
}
/*! @} */

#ifdef _MSC_VER
#pragma warning(pop)
#endif