tinyspline.h

Go to the documentation of this file.

#ifndef TINYSPLINE_H
#define TINYSPLINE_H

#include <stddef.h>


#ifdef  __cplusplus
extern "C" {
#endif

/********************************************************
*                                                       *
* System dependent configuration                        *
*                                                       *
********************************************************/
#ifdef TINYSPLINE_DOUBLE_PRECISION
typedef double tsRational;
#else
typedef float tsRational;
#endif


/********************************************************
*                                                       *
* Data                                                  *
*                                                       *
********************************************************/
typedef enum
{
    TS_SUCCESS = 0,         /* no error */
    TS_MALLOC = -1,         /* malloc/realloc returned null */
    TS_DIM_ZERO = -2,       /* the dimension of the control points are 0 */
    TS_DEG_GE_NCTRLP = -3,  /* degree of spline >= number of control points */
    TS_U_UNDEFINED = -4,    /* spline is not defined at u */
    TS_MULTIPLICITY = -5,   /* the multiplicity of a knot is greater than
                             * the order of the spline */
    TS_KNOTS_DECR = -6,     /* decreasing knot vector */
    TS_NUM_KNOTS = -7,      /* unexpected number of knots */
    TS_UNDERIVABLE = -8     /* spline is not derivable */
} tsError;

typedef enum
{
/* setup knots as... */
    TS_OPENED = 0,  /* [uniformly spaced] */
    TS_CLAMPED = 1, /* [u_1 = u_2 = ..., uniformly spaced, ... = u_n-1 = u_n] */
    TS_BEZIERS = 2, /* uniformly spaced with s(u) = order for all u in knots */
    TS_NONE = 3     /* do not setup the knots; they may have any values */
} tsBSplineType;

typedef struct
{
    tsRational u;       /* the knot u */
    size_t k;           /* the index [u_k, u_k+1) */
    size_t s;           /* the multiplicity of u_k */
    size_t h;           /* how many times u must be inserted */
    size_t dim;         /* dimension of a control point */
    size_t n_points;    /* number of control points */
    tsRational* points; /* the control points of the de Boor net */
    tsRational* result; /* the result of the evaluation
 * Technically it is a pointer to the last point in points. Any changes made
 * here will modify points and vice versa. In case of a discontinuous B-Spline
 * at u, points can be used to get access to the first point and result to get
 * access to the second one. */
} tsDeBoorNet;

typedef struct
{
    size_t deg;        /* degree of b-spline basis function */
    size_t order;      /* degree + 1
 * This field is provided for convenience, because some libraries (e.g. OpenGL)
 * implicitly describing a polynomial of degree n with n + 1. */
    size_t dim;        /* dimension of a control point */
    size_t n_ctrlp;    /* number of control points */
    size_t n_knots;    /* number of knots (n_ctrlp + deg + 1) */
    tsRational* ctrlp; /* the control points of the spline */
    tsRational* knots; /* the knot vector of the spline (ascending)
 * Technically ctrlp and knots share the same array. The first elements of
 * this array are the control points and the last elements are the knots. Keep
 * in mind that you should never assign two different arrays to ctrlp and knots
 * otherwise function provided by this library may result in undefined
 * behaviour. */
} tsBSpline;


/********************************************************
*                                                       *
* Methods                                               *
*                                                       *
********************************************************/
void ts_deboornet_default(tsDeBoorNet* deBoorNet);

void ts_deboornet_free(tsDeBoorNet* deBoorNet);

void ts_bspline_default(tsBSpline* bspline);

void ts_bspline_free(tsBSpline* bspline);

void ts_bspline_move(tsBSpline* from, tsBSpline* to);

tsError ts_bspline_new(
    const size_t deg, const size_t dim,
    const size_t n_ctrlp, const tsBSplineType type,
    tsBSpline* bspline
);

tsError ts_bspline_interpolate(
    const tsRational* points, const size_t n, const size_t dim,
    tsBSpline* bspline
);

tsError ts_bspline_derive(
   const tsBSpline* original,
   tsBSpline* derivative
);

tsError ts_deboornet_copy(
    const tsDeBoorNet* original,
    tsDeBoorNet* copy
);

tsError ts_bspline_copy(
    const tsBSpline* original,
    tsBSpline* copy
);

tsError ts_bspline_set_ctrlp(
    const tsBSpline* bspline, const tsRational* ctrlp,
    tsBSpline* result
);

tsError ts_bspline_set_knots(
    const tsBSpline* bspline, const tsRational* knots,
    tsBSpline* result
);

tsError ts_bspline_setup_knots(
    const tsBSpline* original, const tsBSplineType type,
    const tsRational min, const tsRational max,
    tsBSpline* result
);

tsError ts_bspline_evaluate(
    const tsBSpline* bspline, const tsRational u,
    tsDeBoorNet* deBoorNet
);

tsError ts_bspline_insert_knot(
    const tsBSpline* bspline, const tsRational u, const size_t n,
    tsBSpline* result, size_t* k
);

tsError ts_bspline_resize(
    const tsBSpline* bspline, const int n, const int back,
    tsBSpline* resized
);

tsError ts_bspline_split(
    const tsBSpline* bspline, const tsRational u,
    tsBSpline* split, size_t* k
);

tsError ts_bspline_buckle(
    const tsBSpline* original, const tsRational b,
    tsBSpline* buckled
);

tsError ts_bspline_to_beziers(
    const tsBSpline* bspline,
    tsBSpline* beziers
);


/********************************************************
*                                                       *
* Utility                                               *
*                                                       *
********************************************************/
int ts_fequals(const tsRational x, const tsRational y);

char* ts_enum_str(const tsError err);

tsError ts_str_enum(const char* str);

void ts_ffill(tsRational* arr, const size_t num, const tsRational val);


#ifdef  __cplusplus
}
#endif

#endif  /* TINYSPLINE_H */