/** @file */

#pragma once

#include "tinyspline.h"
#include <vector>
#include <string>

#ifndef TINYSPLINECXX_API
#define TINYSPLINECXX_API TINYSPLINE_API
#endif



/*! @name Emscripten Extensions
 *
 * Please see the following references for more details on how to use
 * Emscripten with C++:
 *
 * https://emscripten.org/docs/porting/connecting_cpp_and_javascript/embind.html
 * https://emscripten.org/docs/api_reference/bind.h.html
 *
 * @{
 */
#ifdef TINYSPLINE_EMSCRIPTEN

// Additional includes and namespaces.
#include <stdexcept>
#include <emscripten/bind.h>
using namespace emscripten;

/* Used by value_objects to guard read-only properties. */
void inline
cannotWrite()
{ throw std::runtime_error("cannot write read-only property"); }

/* Allow clients to read exception messages in the Javascript binding. */
std::string
exceptionMessage(int ptr)
{ return std::string(reinterpret_cast<std::exception *>(ptr)->what()); }

// Map: std::vector <--> JS array
// https://github.com/emscripten-core/emscripten/issues/11070#issuecomment-717675128
namespace emscripten {
namespace internal {
template <typename T, typename Allocator>
struct BindingType<std::vector<T, Allocator>> {
	using ValBinding = BindingType<val>;
	using WireType = ValBinding::WireType;

	static WireType
	toWireType(const std::vector<T, Allocator> &vec)
	{ return ValBinding::toWireType(val::array(vec)); }

	static std::vector<T, Allocator>
	fromWireType(WireType value)
	{ return vecFromJSArray<T>(ValBinding::fromWireType(value)); }
};

template <typename T>
struct TypeID<T, // this is ridiculous...
              typename std::enable_if_t<std::is_same<
                  typename Canonicalized<T>::type,
                  std::vector<typename Canonicalized<T>::type::value_type,
                  typename Canonicalized<T>::type::allocator_type>>::value>> {
	static constexpr TYPEID
	get() { return TypeID<val>::get(); }
};
}  // namespace internal
}  // namespace emscripten
#endif
/*! @} */



namespace tinyspline {

/*! @name API Configuration
 *
 * @{
 */
typedef tsReal real;
/*! @} */



/*! @name Swig Type Mapping
 *
 * Methods that do not return or set the value of a class attribute (let's call
 * these methods `non-accessor methods') must return/take instances of
 * std::vector as pointer. Otherwise, they aren't type mapped by Swig to the
 * std::vector representation of the target language.
 *
 * @{
 */
#ifdef SWIG
using std_real_vector_in = std::vector<tinyspline::real> *;
using std_real_vector_out = std::vector<tinyspline::real> *;
#else
using std_real_vector_in = const std::vector<tinyspline::real> &;
using std_real_vector_out = std::vector<tinyspline::real>;
#endif
/*! @} */



/*! @name Vector Math
 *
 * Wrapper classes for TinySpline's vector math.
 *
 * @{
 */
class TINYSPLINECXX_API Vec2 {
public:
	Vec2();
	Vec2(real x, real y);

	Vec2 operator+(const Vec2 &other);
	Vec2 operator-(const Vec2 &other);
	Vec2 operator*(real scalar);

	real x() const;
	void setX(real val);
	real y() const;
	void setY(real val);
	std::vector<real> values() const;

	Vec2 add(const Vec2 &other) const;
	Vec2 subtract(const Vec2 &other) const;
	Vec2 multiply(real scalar) const;
	Vec2 normalize() const;
	TS_DEPRECATED Vec2 norm() const;
	real magnitude() const;
	real dot(const Vec2 &other) const;
	real angle(const Vec2 &other) const;
	real distance(const Vec2 &other) const;

	std::string toString() const;

private:
	real m_vals[2];

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	void setValues(std::vector<real>) { cannotWrite(); }
#endif
};

class TINYSPLINECXX_API Vec3 {
public:
	Vec3();
	Vec3(real x, real y, real z);

	Vec3 operator+(const Vec3 &other);
	Vec3 operator-(const Vec3 &other);
	Vec3 operator*(real scalar);

	real x() const;
	void setX(real val);
	real y() const;
	void setY(real val);
	real z() const;
	void setZ(real val);
	std::vector<real> values() const;

	Vec3 add(const Vec3 &other) const;
	Vec3 subtract(const Vec3 &other) const;
	Vec3 multiply(real scalar) const;
	Vec3 cross(const Vec3 &other) const;
	Vec3 normalize() const;
	TS_DEPRECATED Vec3 norm() const;
	real magnitude() const;
	real dot(const Vec3 &other) const;
	real angle(const Vec3 &other) const;
	real distance(const Vec3 &other) const;

	std::string toString() const;

private:
	real m_vals[3];

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	void setValues(std::vector<real>) { cannotWrite(); }
#endif
};

class TINYSPLINECXX_API Vec4 {
public:
	Vec4();
	Vec4(real x, real y, real z, real w);

	Vec4 operator+(const Vec4 &other);
	Vec4 operator-(const Vec4 &other);
	Vec4 operator*(real scalar);

	real x() const;
	void setX(real val);
	real y() const;
	void setY(real val);
	real z() const;
	void setZ(real val);
	real w() const;
	void setW(real val);
	std::vector<real> values() const;

	Vec4 add(const Vec4 &other) const;
	Vec4 subtract(const Vec4 &other) const;
	Vec4 multiply(real scalar) const;
	Vec4 normalize() const;
	TS_DEPRECATED Vec4 norm() const;
	real magnitude() const;
	real dot(const Vec4 &other) const;
	real angle(const Vec4 &other) const;
	real distance(const Vec4 &other) const;

	std::string toString() const;

private:
	real m_vals[4];

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	void setValues(std::vector<real>) { cannotWrite(); }
#endif
};

#ifdef TINYSPLINE_EMSCRIPTEN
class VecMath {
public:
	/*! @name Add
	*
	* @{
	*/
	static Vec2
	add2(const Vec2 &a, const Vec2 &b)
	{ return a.add(b); }

	static Vec3
	add3(const Vec3 &a, const Vec3 &b)
	{ return a.add(b); }

	static Vec4
	add4(const Vec4 &a, const Vec4 &b)
	{ return a.add(b); }
	/*! @} */

	/*! @name Subtract
	*
	* @{
	*/
	static Vec2
	subtract2(const Vec2 &a, const Vec2 &b)
	{ return a.subtract(b); }

	static Vec3
	subtract3(const Vec3 &a, const Vec3 &b)
	{ return a.subtract(b); }

	static Vec4
	subtract4(const Vec4 &a, const Vec4 &b)
	{ return a.subtract(b); }
	/*! @} */

	/*! @name Multiply
	*
	* @{
	*/
	static Vec2
	multiply2(const Vec2 &vec, real scalar)
	{ return vec.multiply(scalar); }

	static Vec3
	multiply3(const Vec3 &vec, real scalar)
	{ return vec.multiply(scalar); }

	static Vec4
	multiply4(const Vec4 &vec, real scalar)
	{ return vec.multiply(scalar); }
	/*! @} */

	/*! @name Cross
	*
	* @{
	*/
	static Vec3
	cross3(const Vec3 &a, Vec3 &b)
	{ return a.cross(b); }
	/*! @} */

	/*! @name Normalize
	*
	* @{
	*/
	static Vec2
	normalize2(const Vec2 &vec)
	{ return vec.normalize(); }

	static Vec3
	normalize3(const Vec3 &vec)
	{ return vec.normalize(); }

	static Vec4
	normalize4(const Vec4 &vec)
	{ return vec.normalize(); }
	/*! @} */

	/*! @name Magnitude
	*
	* @{
	*/
	static real
	magnitude2(const Vec2 &vec)
	{ return vec.magnitude(); }

	static real
	magnitude3(const Vec3 &vec)
	{ return vec.magnitude(); }

	static real
	magnitude4(const Vec4 &vec)
	{ return vec.magnitude(); }
	/*! @} */

	/*! @name Dot
	*
	* @{
	*/
	static real
	dot2(const Vec2 &a, Vec2 &b)
	{ return a.dot(b); }

	static real
	dot3(const Vec3 &a, Vec3 &b)
	{ return a.dot(b); }

	static real
	dot4(const Vec4 &a, Vec4 &b)
	{ return a.dot(b); }
	/*! @} */

	/*! @name Angle
	*
	* @{
	*/
	static real
	angle2(const Vec2 &a, Vec2 &b)
	{ return a.angle(b); }

	static real
	angle3(const Vec3 &a, Vec3 &b)
	{ return a.angle(b); }

	static real
	angle4(const Vec4 &a, Vec4 &b)
	{ return a.angle(b); }
	/*! @} */

	/*! @name Distance
	*
	* @{
	*/
	static real
	distance2(const Vec2 &a, Vec2 &b)
	{ return a.distance(b); }

	static real
	distance3(const Vec3 &a, Vec3 &b)
	{ return a.distance(b); }

	static real
	distance4(const Vec4 &a, Vec4 &b)
	{ return a.distance(b); }
	/*! @} */
};
#endif
/*! @} */



/*! @name Spline Framing
 *
 * Object-oriented representation of ::tsFrame (::Frame) and sequences of
 * ::tsFrame (::FrameSeq). Instances of ::FrameSeq are created by
 * ::BSpline::computeRMF.
 *
 * @{
 */
class TINYSPLINECXX_API Frame {
public:
	Frame(Vec3 &position,
	      Vec3 &tangent,
	      Vec3 &normal,
	      Vec3 &binormal);

	Vec3 position() const;
	Vec3 tangent() const;
	Vec3 normal() const;
	Vec3 binormal() const;

	std::string toString() const;

private:
	Vec3 m_position,
	     m_tangent,
	     m_normal,
	     m_binormal;

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	Frame() {}
	void setPosition(Vec3) { cannotWrite(); }
	void setTangent(Vec3) { cannotWrite(); }
	void setNormal(Vec3) { cannotWrite(); }
	void setBinormal(Vec3) { cannotWrite(); }
#endif
};

class TINYSPLINECXX_API FrameSeq {
public:
	FrameSeq();
	FrameSeq(const FrameSeq &other);
	FrameSeq(FrameSeq &&other);
	virtual ~FrameSeq();

	FrameSeq &operator=(const FrameSeq &other);
	FrameSeq &operator=(FrameSeq &&other);

	size_t size() const;
	Frame at(size_t idx) const;

	std::string toString() const;

private:
	tsFrame *m_frames;
	size_t m_size;
	FrameSeq(tsFrame *frames,
	         size_t len);
	friend class BSpline;
};
/*! @} */



/*! @name Utility Classes
 *
 * Little helper classes, such as value classes or classes with only static
 * methods. These are primarily classes that do not really fit into another
 * group or are too small to form their own group.
 *
 * @{
 */
class TINYSPLINECXX_API Domain {
public:
	/* Constructors & Destructors */
	Domain(real min, real max);

	/* Accessors */
	real min() const;
	real max() const;

	/* Debug */
	std::string toString() const;

private:
	real m_min,
	     m_max;

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	Domain()
	: Domain(TS_DOMAIN_DEFAULT_MIN, TS_DOMAIN_DEFAULT_MAX)
	{}
	void setMin(real) { cannotWrite(); }
	void setMax(real) { cannotWrite(); }
#endif
};
/*! @} */



class TINYSPLINECXX_API DeBoorNet {
public:
	/* Constructors & Destructors */
	DeBoorNet(const DeBoorNet &other);
	DeBoorNet(DeBoorNet &&other);
	virtual ~DeBoorNet();

	/* Operators */
	DeBoorNet & operator=(const DeBoorNet &other);
	DeBoorNet & operator=(DeBoorNet &&other);

	/* Accessors */
	real knot() const;
	size_t index() const;
	size_t multiplicity() const;
	size_t numInsertions() const;
	size_t dimension() const;
	std::vector<real> points() const;
	std::vector<real> result() const;

	/**
	* Returns the result at \p idx as ::Vec2. Note that, by design, \p idx
	* cannot be greater than \c 1. It is safe to call this method even if
	* ::dimension is less than \c 2. In this case, the missing components
	* are set to \c 0. If ::dimension is greater than \c 2, the excess
	* values are ignored.
	*
	* @return
	* 	The result at \p idx as ::Vec2.
	* @throws std::out_of_range
	* 	If \p idx is greater than \c 1, or if \p idx is \c 1, but there
	* 	is only one result.
	*/
	Vec2 resultVec2(size_t idx = 0) const;

	/**
	* Returns the result at \p idx as ::Vec3. Note that, by design, \p idx
	* cannot be greater than \c 1. It is safe to call this method even if
	* ::dimension is less than \c 3. In this case, the missing components
	* are set to \c 0. If ::dimension is greater than \c 3, the excess
	* values are ignored.
	*
	* @return
	* 	The result at \p idx as ::Vec3.
	* @throws std::out_of_range
	* 	If \p idx is greater than \c 1, or if \p idx is \c 1, but there
	* 	is only one result.
	*/
	Vec3 resultVec3(size_t idx = 0) const;

	/**
	* Returns the result at \p idx as ::Vec4. Note that, by design, \p idx
	* cannot be greater than \c 1. It is safe to call this method even if
	* ::dimension is less than \c 4. In this case, the missing components
	* are set to \c 0. If ::dimension is greater than \c 4, the excess
	* values are ignored.
	*
	* @return
	* 	The result at \p idx as ::Vec4.
	* @throws std::out_of_range
	* 	If \p idx is greater than \c 1, or if \p idx is \c 1, but there
	* 	is only one result.
	*/
	Vec4 resultVec4(size_t idx = 0) const;

	/* Debug */
	std::string toString() const;

private:
	tsDeBoorNet net;

	/* Constructors & Destructors */
	explicit DeBoorNet(tsDeBoorNet &data);

	friend class BSpline;

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	DeBoorNet() : net(ts_deboornet_init()) {}
	void setKnot(real) { cannotWrite(); }
	void setIndex(size_t) { cannotWrite(); }
	void setMultiplicity(size_t) { cannotWrite(); }
	void setNumInsertions(size_t) { cannotWrite(); }
	void setDimension(size_t) { cannotWrite(); }
	void setPoints(std::vector<real>) { cannotWrite(); }
	void setResult(std::vector<real>) { cannotWrite(); }
#endif
};



class Morphism;
class ChordLengths;
class TINYSPLINECXX_API BSpline {
public:
	enum Type { Opened, Clamped, Beziers };

	/* Constructors & Destructors */
	BSpline();
	BSpline(const BSpline &other);
	BSpline(BSpline &&other);
	explicit BSpline(size_t numControlPoints,
	                 size_t dimension = 2,
	                 size_t degree = 3,
	                 Type type = Type::Clamped);
	virtual ~BSpline();

	/* Create from static method */
	static BSpline interpolateCubicNatural(std_real_vector_in points,
	                                       size_t dimension);
	static BSpline interpolateCatmullRom(std_real_vector_in points,
	                                     size_t dimension,
	                                     real alpha = (real) 0.5,
	                                     std::vector<real> *first = nullptr,
	                                     std::vector<real> *last = nullptr,
	                                     real epsilon = TS_POINT_EPSILON);
	static BSpline parseJson(std::string json);
	static BSpline load(std::string path);

	static bool knotsEqual(real x, real y);

	/* Operators */
	BSpline & operator=(const BSpline &other);
	BSpline & operator=(BSpline &&other);
	DeBoorNet operator()(real u) const;

	/* Accessors */
	size_t degree() const;
	size_t order() const;
	size_t dimension() const;
	std::vector<real> controlPoints() const;
	Vec2 controlPointVec2At(size_t idx) const;
	Vec3 controlPointVec3At(size_t idx) const;
	Vec4 controlPointVec4At(size_t idx) const;
	std::vector<real> knots() const;
	real knotAt(size_t index) const;

	/* Query */
	size_t numControlPoints() const;
	DeBoorNet eval(real u) const;
	std_real_vector_out evalAll(std_real_vector_in knots) const;
	std_real_vector_out sample(size_t num = 0) const;
	DeBoorNet bisect(real value,
	                 real epsilon = (real) 0.0,
	                 bool persnickety = false,
	                 size_t index = 0,
	                 bool ascending = true,
	                 size_t maxIter = 50) const;
	Domain domain() const;
	bool isClosed(real epsilon = TS_POINT_EPSILON) const;
	FrameSeq computeRMF(std_real_vector_in knots,
	                    Vec3 *firstNormal = nullptr) const;
	BSpline subSpline(real knot0, real knot1) const;
	std_real_vector_out uniformKnotSeq(size_t num = 100) const;
	std_real_vector_out equidistantKnotSeq(size_t num = 100,
	                                       size_t numSamples = 0) const;
	ChordLengths chordLengths(std_real_vector_in knots) const;
	ChordLengths chordLengths(size_t numSamples = 200) const;

	/* Serialization */
	std::string toJson() const;
	void save(std::string path) const;

	/* Modifications */
	void setControlPoints(const std::vector<real> &ctrlp);
	void setControlPointVec2At(size_t idx, Vec2 &cp);
	void setControlPointVec3At(size_t idx, Vec3 &cp);
	void setControlPointVec4At(size_t idx, Vec4 &cp);
	void setKnots(const std::vector<real> &knots);
	void setKnotAt(size_t index, real knot);

	/* Transformations */
	BSpline insertKnot(real u, size_t n) const;
	BSpline split(real u) const;
	BSpline tension(real tension) const;
	BSpline toBeziers() const;
	BSpline derive(size_t n = 1,
		real epsilon = TS_POINT_EPSILON) const;
	BSpline elevateDegree(size_t amount,
		real epsilon = TS_POINT_EPSILON) const;
	BSpline alignWith(const BSpline &other, BSpline &otherAligned,
		real epsilon = TS_POINT_EPSILON) const;
	Morphism morphTo(const BSpline &other,
		real epsilon = TS_POINT_EPSILON) const;

	/* Debug */
	std::string toString() const;

private:
	tsBSpline spline;

	/* Constructors & Destructors */
	explicit BSpline(tsBSpline &data);

	/* Needs to access ::spline. */
	friend class Morphism;

#ifdef TINYSPLINE_EMSCRIPTEN
public:
	std_real_vector_out sample0() const { return sample(); }
	std_real_vector_out sample1(size_t num) const { return sample(num); }
	BSpline derive0() const { return derive(); }
	BSpline derive1(size_t n) const { return derive(n); }
	BSpline derive2(size_t n, real eps) const { return derive(n, eps); }
#endif
};



/*! @name Spline Morphing
 *
 * @{
 */
class TINYSPLINECXX_API Morphism {
public:
	Morphism(const BSpline &origin,
		 const BSpline &target,
		 real epsilon = TS_POINT_EPSILON);

	BSpline origin() const;
	BSpline target() const;
	real epsilon() const;

	BSpline eval(real t);
	BSpline operator()(real t);

	std::string toString() const;
private:
	BSpline m_origin, m_target;
	real m_epsilon;
	BSpline m_originAligned, m_targetAligned;
	BSpline m_buffer;
};
/*! @} */



/*! @name Reparametrization by Arc Length
 * @{
 */
class TINYSPLINECXX_API ChordLengths {
public:
	ChordLengths();
	ChordLengths(const ChordLengths &other);
	ChordLengths(ChordLengths &&other);
	virtual ~ChordLengths();

	ChordLengths &operator=(const ChordLengths &other);
	ChordLengths &operator=(ChordLengths &&other);

	BSpline spline() const;
	std::vector<real> knots() const;
	std::vector<real> values() const;
	size_t size() const;

	real arcLength() const;
	real lengthToKnot(real len) const;
	real tToKnot(real t) const;

	std::string toString() const;
private:
	BSpline m_spline;
	real *m_knots, *m_chordLengths;
	size_t m_size;
	ChordLengths(const BSpline &spline,
	             real *knots,
	             real *chordLengths,
	             size_t size);
	friend class BSpline;
};
/*! @} */

}



#ifdef TINYSPLINE_EMSCRIPTEN
using namespace tinyspline;
EMSCRIPTEN_BINDINGS(tinyspline) {
	function("exceptionMessage", &exceptionMessage);

	// Vector Math
	value_object<Vec2>("Vec2")
		.field("x",
		       &Vec2::x,
		       &Vec2::setX)
		.field("y",
		       &Vec2::y,
		       &Vec2::setY)
		.field("values",
		       &Vec2::values,
		       &Vec2::setValues)
	;
	value_object<Vec3>("Vec3")
		.field("x",
		       &Vec3::x,
		       &Vec3::setX)
		.field("y",
		       &Vec3::y,
		       &Vec3::setY)
		.field("z",
		       &Vec3::z,
		       &Vec3::setZ)
		.field("values",
		       &Vec3::values,
		       &Vec3::setValues)
	;
	value_object<Vec4>("Vec4")
		.field("x",
		       &Vec4::x,
		       &Vec4::setX)
		.field("y",
		       &Vec4::y,
		       &Vec4::setY)
		.field("z",
		       &Vec4::z,
		       &Vec4::setZ)
		.field("w",
		       &Vec4::w,
		       &Vec4::setW)
		.field("values",
		       &Vec4::values,
		       &Vec4::setValues)
	;
	class_<VecMath>("VecMath")
		.class_function("add", &VecMath::add2)
		.class_function("add", &VecMath::add3)
		.class_function("add", &VecMath::add4)
		.class_function("subtract", &VecMath::subtract2)
		.class_function("subtract", &VecMath::subtract3)
		.class_function("subtract", &VecMath::subtract4)
		.class_function("multiply", &VecMath::multiply2)
		.class_function("multiply", &VecMath::multiply3)
		.class_function("multiply", &VecMath::multiply4)
		.class_function("cross", &VecMath::cross3)
		.class_function("normalize", &VecMath::normalize2)
		.class_function("normalize", &VecMath::normalize3)
		.class_function("normalize", &VecMath::normalize4)
		.class_function("magnitude", &VecMath::magnitude2)
		.class_function("magnitude", &VecMath::magnitude3)
		.class_function("magnitude", &VecMath::magnitude4)
		.class_function("dot", &VecMath::dot2)
		.class_function("dot", &VecMath::dot3)
		.class_function("dot", &VecMath::dot4)
		.class_function("angle", &VecMath::angle2)
		.class_function("angle", &VecMath::angle3)
		.class_function("angle", &VecMath::angle4)
		.class_function("distance", &VecMath::distance2)
		.class_function("distance", &VecMath::distance3)
		.class_function("distance", &VecMath::distance4)
	;

	// Spline Framing
	value_object<Frame>("Frame")
		.field("position",
		       &Frame::position,
		       &Frame::setPosition)
		.field("tangent",
		       &Frame::tangent,
		       &Frame::setTangent)
		.field("normal",
		       &Frame::normal,
		       &Frame::setNormal)
		.field("binormal",
		       &Frame::normal,
		       &Frame::setNormal)
	;
	class_<FrameSeq>("FrameSeq")
		.constructor<>()
		.constructor<FrameSeq>()
		.function("size", &FrameSeq::size)
		.function("at", &FrameSeq::at)
		.function("toString", &FrameSeq::toString)
	;

	// Utility Classes
	value_object<Domain>("Domain")
		.field("min",
		       &Domain::min,
		       &Domain::setMin)
		.field("max",
		       &Domain::max,
		       &Domain::setMax)
	;

	value_object<DeBoorNet>("DeBoorNet")
		.field("knot",
		       &DeBoorNet::knot,
		       &DeBoorNet::setKnot)
		.field("index",
		       &DeBoorNet::index,
		       &DeBoorNet::setIndex)
		.field("multiplicity",
		       &DeBoorNet::multiplicity,
		       &DeBoorNet::setMultiplicity)
		.field("numInsertions",
		       &DeBoorNet::numInsertions,
		       &DeBoorNet::setNumInsertions)
		.field("dimension",
		       &DeBoorNet::dimension,
		       &DeBoorNet::setDimension)
		.field("points",
		       &DeBoorNet::points,
		       &DeBoorNet::setPoints)
		.field("result",
		       &DeBoorNet::result,
		       &DeBoorNet::setResult)
	;

	class_<BSpline>("BSpline")
	        .constructor<>()
	        //.constructor<BSpline>()
	        .constructor<size_t>()
	        .constructor<size_t, size_t>()
	        .constructor<size_t, size_t, size_t>()
	        .constructor<size_t, size_t, size_t, BSpline::Type>()

	        .class_function("interpolateCubicNatural",
			&BSpline::interpolateCubicNatural)
	        .class_function("interpolateCatmullRom",
			&BSpline::interpolateCatmullRom,
			allow_raw_pointers())
	        .class_function("parseJson", &BSpline::parseJson)

	        .property("degree", &BSpline::degree)
	        .property("order", &BSpline::order)
	        .property("dimension", &BSpline::dimension)
	        .property("controlPoints", &BSpline::controlPoints,
			&BSpline::setControlPoints)
	        .property("knots", &BSpline::knots, &BSpline::setKnots)
	        .property("domain", &BSpline::domain)

	        /* Property by index */
	        .function("knotAt", &BSpline::knotAt)
	        .function("setKnotAt", &BSpline::setKnotAt)

	        /* Query */
	        .function("numControlPoints", &BSpline::numControlPoints)
	        .function("eval", &BSpline::eval)
	        .function("evalAll", &BSpline::evalAll)
	        .function("sample",
			select_overload<std_real_vector_out() const>
			(&BSpline::sample0))
	        .function("sample",
			select_overload<std_real_vector_out(size_t) const>
			(&BSpline::sample1))
	        .function("sample", &BSpline::sample)
	        .function("bisect", &BSpline::bisect)
	        .function("isClosed", &BSpline::isClosed)

		/* Serialization */
	        .function("toJson", &BSpline::toJson)

	        /* Transformations */
	        .function("insertKnot", &BSpline::insertKnot)
	        .function("split", &BSpline::split)
	        .function("tension", &BSpline::tension)
	        .function("toBeziers", &BSpline::toBeziers)
	        .function("derive",
			select_overload<BSpline() const>
			(&BSpline::derive0))
	        .function("derive",
			select_overload<BSpline(size_t) const>
			(&BSpline::derive1))
	        .function("derive",
			select_overload<BSpline(size_t, real) const>
			(&BSpline::derive2))

	        /* Debug */
	        .function("toString", &BSpline::toString)
	;

	enum_<BSpline::Type>("BSplineType")
	        .value("Opened", BSpline::Type::Opened)
	        .value("Clamped", BSpline::Type::Clamped)
	        .value("Beziers", BSpline::Type::Beziers)
	;
}
#endif