tinyspline.h

Go to the documentation of this file.

 
#ifndef TINYSPLINE_H
#define TINYSPLINE_H
 
#include <stddef.h>
 
 
 
#if defined(__GNUC__) || defined(__clang__)
#define TS_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define TS_DEPRECATED __declspec(deprecated)
#elif defined(SWIG)
#define TS_DEPRECATED
#else
#warning "WARNING: TS_DEPRECATED is not supported by the compiler"
#define TS_DEPRECATED
#endif
#if !defined(TINYSPLINE_API)
#if defined(_WIN32) || defined(__CYGWIN__)
#define TINYSPLINE_SHARED_EXPORT __declspec(dllexport)
#define TINYSPLINE_SHARED_IMPORT __declspec(dllimport)
#elif defined(__ELF__) || defined(__MACH__)
#define TINYSPLINE_SHARED_EXPORT __attribute__ ((visibility ("default")))
#define TINYSPLINE_SHARED_IMPORT
#else
#define TINYSPLINE_SHARED_EXPORT
#define TINYSPLINE_SHARED_IMPORT
#endif
 
#ifdef TINYSPLINE_SHARED
#ifdef TINYSPLINE_EXPORT
#define TINYSPLINE_API TINYSPLINE_SHARED_EXPORT
#else
#define TINYSPLINE_API TINYSPLINE_SHARED_IMPORT
#endif
#else
#define TINYSPLINE_API
#endif
#endif
 
#ifdef  __cplusplus
extern "C" {
#endif
#define TS_PI 3.14159265358979323846
 
#define TS_MAX_NUM_KNOTS 10000
 
#define TS_DOMAIN_DEFAULT_MIN 0.0f
 
#define TS_DOMAIN_DEFAULT_MAX 1.0f
 
#define TS_KNOT_EPSILON 1e-4f
 
#ifdef TINYSPLINE_FLOAT_PRECISION
#define TS_POINT_EPSILON 1e-3f
#else
#define TS_POINT_EPSILON 1e-5f
#endif
 
#ifdef TINYSPLINE_FLOAT_PRECISION
#define TS_LENGTH_ZERO 1e-3f
#else
#define TS_LENGTH_ZERO 1e-4f
#endif
#ifdef TINYSPLINE_FLOAT_PRECISION
typedef float tsReal;
#else
typedef double tsReal;
#endif
typedef enum
{
    TS_SUCCESS = 0,
 
    TS_MALLOC = -1,
 
    TS_DIM_ZERO = -2,
 
    TS_DEG_GE_NCTRLP = -3,
 
    TS_U_UNDEFINED = -4,
 
    TS_MULTIPLICITY = -5,
 
    TS_KNOTS_DECR = -6,
 
    TS_NUM_KNOTS = -7,
 
    TS_UNDERIVABLE = -8,
 
    TS_LCTRLP_DIM_MISMATCH = -10,
 
    TS_IO_ERROR = -11,
 
    TS_PARSE_ERROR = -12,
 
    TS_INDEX_ERROR = -13,
 
    TS_NO_RESULT = -14,
 
    TS_NUM_POINTS = -15
} tsError;
 
typedef struct
{
    tsError code;
 
    char message[100];
} tsStatus;
 
#define TS_TRY(label, error, status)         \
{                                            \
    (error) = TS_SUCCESS;                \
    if ((status) != NULL) {              \
        (status)->code = TS_SUCCESS; \
        (status)->message[0] = '\0'; \
    }                                    \
    __ ## label ## __:                   \
    if (!(error)) {
 
#define TS_CALL(label, error, call)                  \
        (error) = (call);                    \
        if ((error)) goto __ ## label ## __;
 
#define TS_CATCH(error) \
    } if ((error)) {
 
#define TS_FINALLY \
    } {
 
#define TS_END_TRY \
    }          \
}
 
#define TS_END_TRY_RETURN(error)   \
    TS_END_TRY return (error);
 
#define TS_END_TRY_ROE(error)                 \
    TS_END_TRY if ((error)) return error;
 
#define TS_CALL_ROE(error, call)   \
{                                  \
    (error) = (call);          \
    if ((error)) return error; \
}
 
#define TS_RETURN_SUCCESS(status)            \
{                                            \
    if ((status) != NULL) {              \
        (status)->code = TS_SUCCESS; \
        (status)->message[0] = '\0'; \
    }                                    \
    return TS_SUCCESS;                   \
}
 
#define TS_RETURN_0(status, error, msg)          \
{                                                \
    if ((status) != NULL) {                  \
        (status)->code = error;          \
        sprintf((status)->message, msg); \
    }                                        \
    return error;                            \
}
 
#define TS_RETURN_1(status, error, msg, arg1)          \
{                                                      \
    if ((status) != NULL) {                        \
        (status)->code = error;                \
        sprintf((status)->message, msg, arg1); \
    }                                              \
    return error;                                  \
}
 
#define TS_RETURN_2(status, error, msg, arg1, arg2)          \
{                                                            \
    if ((status) != NULL) {                              \
        (status)->code = error;                      \
        sprintf((status)->message, msg, arg1, arg2); \
    }                                                    \
    return error;                                        \
}
 
#define TS_RETURN_3(status, error, msg, arg1, arg2, arg3)          \
{                                                                  \
    if ((status) != NULL) {                                    \
        (status)->code = error;                            \
        sprintf((status)->message, msg, arg1, arg2, arg3); \
    }                                                          \
    return error;                                              \
}
 
#define TS_RETURN_4(status, error, msg, arg1, arg2, arg3, arg4)          \
{                                                                        \
    if ((status) != NULL) {                                          \
        (status)->code = error;                                  \
        sprintf((status)->message, msg, arg1, arg2, arg3, arg4); \
    }                                                                \
    return error;                                                    \
}
 
#define TS_THROW_0(label, error, status, val, msg) \
{                                                  \
    (error) = val;                             \
    if ((status) != NULL) {                    \
        (status)->code = val;              \
        sprintf((status)->message, msg);   \
    }                                          \
    goto __ ## label ## __;                    \
}
 
#define TS_THROW_1(label, error, status, val, msg, arg1) \
{                                                        \
    (error) = val;                                   \
    if ((status) != NULL) {                          \
        (status)->code = val;                    \
        sprintf((status)->message, msg, arg1);   \
    }                                                \
    goto __ ## label ## __;                          \
}
 
#define TS_THROW_2(label, error, status, val, msg, arg1, arg2) \
{                                                              \
    (error) = val;                                         \
    if ((status) != NULL) {                                \
        (status)->code = val;                          \
        sprintf((status)->message, msg, arg1, arg2);   \
    }                                                      \
    goto __ ## label ## __;                                \
}
 
#define TS_THROW_3(label, error, status, val, msg, arg1, arg2, arg3) \
{                                                                    \
    (error) = val;                                               \
    if ((status) != NULL) {                                      \
        (status)->code = val;                                \
        sprintf((status)->message, msg, arg1, arg2, arg3);   \
    }                                                            \
    goto __ ## label ## __;                                      \
}
 
#define TS_THROW_4(label, error, status, val, msg, arg1, arg2, arg3, arg4) \
{                                                                          \
    (error) = val;                                                     \
    if ((status) != NULL) {                                            \
        (status)->code = val;                                      \
        sprintf((status)->message, msg, arg1, arg2, arg3, arg4);   \
    }                                                                  \
    goto __ ## label ## __;                                            \
}
typedef enum
{
    TS_OPENED = 0,
 
    TS_CLAMPED = 1,
 
    TS_BEZIERS = 2
} tsBSplineType;
 
typedef struct
{
    tsReal position[3];
 
    tsReal tangent[3];
 
    tsReal normal[3];
 
    tsReal binormal[3];
} tsFrame;
typedef struct
{
    struct tsBSplineImpl *pImpl; 
} tsBSpline;
 
size_t TINYSPLINE_API
ts_bspline_degree(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_order(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_dimension(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_len_control_points(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_num_control_points(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_sof_control_points(const tsBSpline *spline);
 
const tsReal TINYSPLINE_API *
ts_bspline_control_points_ptr(const tsBSpline *spline);
 
tsError TINYSPLINE_API
ts_bspline_control_points(const tsBSpline *spline,
                          tsReal **ctrlp,
                          tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_control_point_at_ptr(const tsBSpline *spline,
                                size_t index,
                                const tsReal **ctrlp,
                                tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_set_control_points(tsBSpline *spline,
                              const tsReal *ctrlp,
                              tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_set_control_point_at(tsBSpline *spline,
                                size_t index,
                                const tsReal *ctrlp,
                                tsStatus *status);
 
size_t TINYSPLINE_API
ts_bspline_num_knots(const tsBSpline *spline);
 
size_t TINYSPLINE_API
ts_bspline_sof_knots(const tsBSpline *spline);
 
const tsReal TINYSPLINE_API *
ts_bspline_knots_ptr(const tsBSpline *spline);
 
tsError TINYSPLINE_API
ts_bspline_knots(const tsBSpline *spline,
                 tsReal **knots,
                 tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_knot_at(const tsBSpline *spline,
                   size_t index,
                   tsReal *knot,
                   tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_set_knots(tsBSpline *spline,
                     const tsReal *knots,
                     tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_set_knots_varargs(tsBSpline *spline,
                             tsStatus *status,
                             tsReal knot0,
                             double knot1,
                             ...);
 
tsError TINYSPLINE_API
ts_bspline_set_knot_at(tsBSpline *spline,
                       size_t index,
                       tsReal knot,
                       tsStatus *status);
tsBSpline TINYSPLINE_API
ts_bspline_init(void);
 
tsError TINYSPLINE_API
ts_bspline_new(size_t num_control_points,
               size_t dimension,
               size_t degree,
               tsBSplineType type,
               tsBSpline *spline,
               tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_new_with_control_points(size_t num_control_points,
                                   size_t dimension,
                                   size_t degree,
                                   tsBSplineType type,
                                   tsBSpline *spline,
                                   tsStatus *status,
                                   double first,
                                   ...);
 
tsError TINYSPLINE_API
ts_bspline_copy(const tsBSpline *src,
                tsBSpline *dest,
                tsStatus *status);
 
void TINYSPLINE_API
ts_bspline_move(tsBSpline *src,
                tsBSpline *dest);
 
void TINYSPLINE_API
ts_bspline_free(tsBSpline *spline);
typedef struct
{
    struct tsDeBoorNetImpl *pImpl; 
} tsDeBoorNet;
 
tsReal TINYSPLINE_API
ts_deboornet_knot(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_index(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_multiplicity(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_num_insertions(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_dimension(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_len_points(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_num_points(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_sof_points(const tsDeBoorNet *net);
 
const tsReal TINYSPLINE_API *
ts_deboornet_points_ptr(const tsDeBoorNet *net);
 
tsError TINYSPLINE_API
ts_deboornet_points(const tsDeBoorNet *net,
                    tsReal **points,
                    tsStatus *status);
 
size_t TINYSPLINE_API
ts_deboornet_len_result(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_num_result(const tsDeBoorNet *net);
 
size_t TINYSPLINE_API
ts_deboornet_sof_result(const tsDeBoorNet *net);
 
const tsReal TINYSPLINE_API *
ts_deboornet_result_ptr(const tsDeBoorNet *net);
 
tsError TINYSPLINE_API
ts_deboornet_result(const tsDeBoorNet *net,
                    tsReal **result,
                    tsStatus *status);
tsDeBoorNet TINYSPLINE_API
ts_deboornet_init(void);
 
tsError TINYSPLINE_API
ts_deboornet_copy(const tsDeBoorNet *src,
                  tsDeBoorNet *dest,
                  tsStatus *status);
 
void TINYSPLINE_API
ts_deboornet_move(tsDeBoorNet *src,
                  tsDeBoorNet *dest);
 
void TINYSPLINE_API
ts_deboornet_free(tsDeBoorNet *net);
tsError TINYSPLINE_API
ts_bspline_interpolate_cubic_natural(const tsReal *points,
                                     size_t num_points,
                                     size_t dimension,
                                     tsBSpline *spline,
                                     tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_interpolate_catmull_rom(const tsReal *points,
                                   size_t num_points,
                                   size_t dimension,
                                   tsReal alpha,
                                   const tsReal *first,
                                   const tsReal *last,
                                   tsReal epsilon,
                                   tsBSpline *spline,
                                   tsStatus *status);
tsError TINYSPLINE_API
ts_bspline_eval(const tsBSpline *spline,
                tsReal knot,
                tsDeBoorNet *net,
                tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_eval_all(const tsBSpline *spline,
                    const tsReal *knots,
                    size_t num,
                    tsReal **points,
                    tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_sample(const tsBSpline *spline,
                  size_t num,
                  tsReal **points,
                  size_t *actual_num,
                  tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_bisect(const tsBSpline *spline,
                  tsReal value,
                  tsReal epsilon,
                  int persnickety,
                  size_t index,
                  int ascending,
                  size_t max_iter,
                  tsDeBoorNet *net,
                  tsStatus *status);
 
void TINYSPLINE_API
ts_bspline_domain(const tsBSpline *spline,
                  tsReal *min,
                  tsReal *max);
 
tsError TINYSPLINE_API
ts_bspline_is_closed(const tsBSpline *spline,
                     tsReal epsilon,
                     int *closed,
                     tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_compute_rmf(const tsBSpline *spline,
                       const tsReal *knots,
                       size_t num,
                       int has_first_normal,
                       tsFrame *frames,
                       tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_chord_lengths(const tsBSpline *spline,
                         const tsReal *knots,
                         size_t num,
                         tsReal *lengths,
                         tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_sub_spline(const tsBSpline *spline,
                      tsReal knot0,
                      tsReal knot1,
                      tsBSpline *sub,
                      tsStatus *status);
 
void TINYSPLINE_API
ts_bspline_uniform_knot_seq(const tsBSpline *spline,
                            size_t num,
                            tsReal *knots);
 
tsError TINYSPLINE_API
ts_bspline_equidistant_knot_seq(const tsBSpline *spline,
                                size_t num,
                                tsReal *knots,
                                size_t num_samples,
                                tsStatus *status);
tsError TINYSPLINE_API
ts_bspline_derive(const tsBSpline *spline,
                  size_t n,
                  tsReal epsilon,
                  tsBSpline *deriv,
                  tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_insert_knot(const tsBSpline *spline,
                       tsReal knot, size_t num,
                       tsBSpline *result,
                       size_t *k,
                       tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_split(const tsBSpline *spline,
                 tsReal knot,
                 tsBSpline *split,
                 size_t *k,
                 tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_tension(const tsBSpline *spline,
                   tsReal beta,
                   tsBSpline *out,
                   tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_to_beziers(const tsBSpline *spline,
                      tsBSpline *beziers,
                      tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_elevate_degree(const tsBSpline *spline,
                          size_t amount,
                          tsReal epsilon,
                          tsBSpline *elevated,
                          tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_align(const tsBSpline *s1,
                 const tsBSpline *s2,
                 tsReal epsilon,
                 tsBSpline *s1_out,
                 tsBSpline *s2_out,
                 tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_morph(const tsBSpline *origin,
                 const tsBSpline *target,
                 tsReal t,
                 tsReal epsilon,
                 tsBSpline *out,
                 tsStatus *status);
#if !defined(TINYSPLINE_NO_SERIALIZATION)
tsError TINYSPLINE_API
ts_bspline_to_json(const tsBSpline *spline,
                   char **json,
                   tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_parse_json(const char *json,
                      tsBSpline *spline,
                      tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_save(const tsBSpline *spline,
                const char *path,
                tsStatus *status);
 
tsError TINYSPLINE_API
ts_bspline_load(const char *path,
                tsBSpline *spline,
                tsStatus *status);
#endif
 
 
void TINYSPLINE_API
ts_vec2_init(tsReal *out,
             tsReal x,
             tsReal y);
 
void TINYSPLINE_API
ts_vec3_init(tsReal *out,
             tsReal x,
             tsReal y,
             tsReal z);
 
void TINYSPLINE_API
ts_vec4_init(tsReal *out,
             tsReal x,
             tsReal y,
             tsReal z,
             tsReal w);
 
void TINYSPLINE_API
ts_vec2_set(tsReal *out,
            const tsReal *x,
            size_t dim);
 
void TINYSPLINE_API
ts_vec3_set(tsReal *out,
            const tsReal *x,
            size_t dim);
 
void TINYSPLINE_API
ts_vec4_set(tsReal *out,
            const tsReal *x,
            size_t dim);
 
void TINYSPLINE_API
ts_vec_add(const tsReal *x,
           const tsReal *y,
           size_t dim,
           tsReal *out);
 
void TINYSPLINE_API
ts_vec_sub(const tsReal *x,
           const tsReal *y,
           size_t dim,
           tsReal *out);
 
tsReal TINYSPLINE_API
ts_vec_dot(const tsReal *x,
           const tsReal *y,
           size_t dim);
 
tsReal TINYSPLINE_API
ts_vec_angle(const tsReal *x,
             const tsReal *y,
             tsReal *buf,
             size_t dim);
 
void TINYSPLINE_API
ts_vec3_cross(const tsReal *x,
              const tsReal *y,
              tsReal *out);
 
void TINYSPLINE_API
ts_vec_norm(const tsReal *x,
            size_t dim,
            tsReal *out);
 
tsReal TINYSPLINE_API
ts_vec_mag(const tsReal *x,
           size_t dim);
 
void TINYSPLINE_API
ts_vec_mul(const tsReal *x,
           size_t dim,
           tsReal val,
           tsReal *out);
tsError TINYSPLINE_API
ts_chord_lengths_length_to_knot(const tsReal *knots,
                                const tsReal *lengths,
                                size_t num,
                                tsReal len,
                                tsReal *knot,
                                tsStatus *status);
 
tsError TINYSPLINE_API
ts_chord_lengths_t_to_knot(const tsReal *knots,
                           const tsReal *lengths,
                           size_t num,
                           tsReal t,
                           tsReal *knot,
                           tsStatus *status);
 
tsError TINYSPLINE_API
ts_chord_lengths_equidistant_knot_seq(const tsReal *knots,
                                      const tsReal *lengths,
                                      size_t num,
                                      size_t num_knot_seq,
                                      tsReal *knot_seq,
                                      tsStatus *status);
int TINYSPLINE_API
ts_knots_equal(tsReal x,
               tsReal y);
 
void TINYSPLINE_API
ts_arr_fill(tsReal *arr,
            size_t num,
            tsReal val);
 
tsReal TINYSPLINE_API
ts_distance(const tsReal *x,
            const tsReal *y,
            size_t dim);
#ifdef  __cplusplus
}
#endif
 
#endif  /* TINYSPLINE_H */