Max 5 API Reference

jit.curve.cubicspline.c

/*
 *  jit.curve.cubicspline.c
 *
 *  Copyright 2001-2005 - Cycling '74
 *  Derek Gerstmann - derek@cycling74.com
 *
 *  functor for a one-dimensional cubic spline
 *
 */

#include "jit.common.h"
#include "jit.functor.h"
#include "jit.cubicspline.h"

// --------------------------------------------------------------------------

typedef struct _jit_functor_curve_cubicspline_cvdata_fixed
{
    long                                    stepcount;
    long                                    spancount;
    long                                    knotcount;
    long                                    *knots;
    t_jit_cubicspline_basismatrix_fixed     matrix;
} t_jit_functor_curve_cubicspline_cvdata_fixed;

typedef struct _jit_functor_curve_cubicspline_cvdata_float32
{
    long                                    stepcount;
    long                                    spancount;
    long                                    knotcount;
    float                                   *knots;
    t_jit_cubicspline_basismatrix_float32   matrix;
} t_jit_functor_curve_cubicspline_cvdata_float32;

typedef struct _jit_functor_curve_cubicspline_cvdata_float64
{
    long                                    stepcount;
    long                                    spancount;
    long                                    knotcount;
    double                                  *knots;
    t_jit_cubicspline_basismatrix_float64   matrix;
} t_jit_functor_curve_cubicspline_cvdata_float64;

typedef struct _jit_functor_curve_cubicspline_cvdata
{
    t_jit_functor_curve_cubicspline_cvdata_fixed fixed;
    t_jit_functor_curve_cubicspline_cvdata_float32 float32;
    t_jit_functor_curve_cubicspline_cvdata_float64 float64;
} t_jit_functor_curve_cubicspline_cvdata;

typedef struct _jit_functor_curve_cubicspline
{
    t_jit_object                            ob;
    t_symbol                                *basis;
    t_jit_functor_curve_cubicspline_cvdata  cvdata; 
} t_jit_functor_curve_cubicspline;

// --------------------------------------------------------------------------

t_jit_object *jit_functor_curve_cubicspline_new(void);
t_jit_err jit_functor_curve_cubicspline_free(t_jit_functor_curve_cubicspline *x);
t_jit_err jit_functor_curve_cubicspline_setattr_knots(t_jit_functor_curve_cubicspline *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_curve_cubicspline_setattr_basis(t_jit_functor_curve_cubicspline *x, void *attr, long argc, t_atom *argv);
t_jit_err jit_functor_curve_cubicspline_recalc(t_jit_functor_curve_cubicspline *x);

t_jit_err jit_functor_curve_cubicspline_resize(t_jit_functor_curve_cubicspline *x, long count);
t_jit_err jit_functor_curve_cubicspline_resize_fixed(t_jit_functor_curve_cubicspline *x, long count);
t_jit_err jit_functor_curve_cubicspline_resize_float32(t_jit_functor_curve_cubicspline *x, long count);
t_jit_err jit_functor_curve_cubicspline_resize_float64(t_jit_functor_curve_cubicspline *x, long count);

double *jit_functor_curve_cubicspline_getknots(t_jit_functor_curve_cubicspline *x);
t_jit_err jit_functor_curve_cubicspline_getknotcount(t_jit_functor_curve_cubicspline *x, long *count);
t_jit_err jit_functor_curve_cubicspline_setknot(t_jit_functor_curve_cubicspline *x, long index, double value);
t_jit_err jit_functor_curve_cubicspline_getknot(t_jit_functor_curve_cubicspline *x, long index, double *value);
t_jit_err jit_functor_curve_cubicspline_setbasis(t_jit_functor_curve_cubicspline *x, t_symbol *name);

t_jit_err jit_functor_curve_cubicspline_resize(t_jit_functor_curve_cubicspline *x, long count);

long jit_functor_curve_cubicspline_eval_fixed(t_jit_functor_curve_cubicspline *x, long dimcount, long *vals);
float jit_functor_curve_cubicspline_eval_float32(t_jit_functor_curve_cubicspline *x, long dimcount, float *vals);
double jit_functor_curve_cubicspline_eval_float64(t_jit_functor_curve_cubicspline *x, long dimcount, double *vals);

long jit_functor_curve_cubicspline_eval_fixed_scalar(t_jit_functor_curve_cubicspline *x, long val);
float jit_functor_curve_cubicspline_eval_float32_scalar(t_jit_functor_curve_cubicspline *x, float val);
double jit_functor_curve_cubicspline_eval_float64_scalar(t_jit_functor_curve_cubicspline *x, double val);

t_class * _jit_functor_curve_cubicspline_class;

// --------------------------------------------------------------------------

t_jit_err jit_functor_curve_cubicspline_init(void)
{
    t_jit_object *attr;

    // create the class
    _jit_functor_curve_cubicspline_class = jit_class_new("jit_functor_curve_cubicspline",
        (method)jit_functor_curve_cubicspline_new,(method)jit_functor_curve_cubicspline_free,
        sizeof(t_jit_functor_curve_cubicspline),0L);

    // add attribute methods
    attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "basis",
        _jit_sym_symbol, 0, (method)0L,(method)jit_functor_curve_cubicspline_setattr_basis,
        calcoffset(t_jit_functor_curve_cubicspline, basis)  );
    jit_class_addattr(_jit_functor_curve_cubicspline_class,attr);
    attr = (t_jit_object*)jit_object_new(_jit_sym_jit_attr_offset, "knots",
        _jit_sym_float64, 0, (method)0L,(method)jit_functor_curve_cubicspline_setattr_knots, 0L );
    jit_class_addattr(_jit_functor_curve_cubicspline_class,attr);

    // add functor evaluation methods
    jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
        (method)jit_functor_curve_cubicspline_eval_fixed, "evalfixed", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
        (method)jit_functor_curve_cubicspline_eval_float32, "evalfloat32", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
        (method)jit_functor_curve_cubicspline_eval_float64, "evalfloat64", A_CANT, 0L);

    // add data access methods
    jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
        (method)jit_functor_curve_cubicspline_resize, "resize", A_CANT, 0L);
//  jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
//      (method)jit_functor_curve_cubicspline_getknot, "getknot", A_CANT, 0L);
//  jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
//      (method)jit_functor_curve_cubicspline_setknot, "setknot", A_CANT, 0L);
    jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
        (method)jit_functor_curve_cubicspline_setbasis, "setbasis", A_CANT, 0L);
//  jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
//      (method)jit_functor_curve_cubicspline_getknots, "getknots", A_CANT, 0L);
//  jit_class_addmethod(_jit_functor_curve_cubicspline_class, 
//      (method)jit_functor_curve_cubicspline_getknotcount, "getknotcount", A_CANT, 0L);

    // add to functor registry and register class
    jit_functor_setup_class(_jit_functor_curve_cubicspline_class,"curve","cubicspline");
    jit_class_register(_jit_functor_curve_cubicspline_class);
    return JIT_ERR_NONE;
}

t_jit_object *jit_functor_curve_cubicspline_new(void)
{
    t_jit_functor_curve_cubicspline *x;

    if (x = (t_jit_functor_curve_cubicspline *)jit_object_alloc(_jit_functor_curve_cubicspline_class)) {

        // initialization
        x->basis = NULL;
        
        x->cvdata.fixed.knots = NULL;
        x->cvdata.fixed.knotcount = 0;
        x->cvdata.fixed.stepcount = 0;
        x->cvdata.fixed.spancount = 0;
        
        x->cvdata.float32.knots = NULL;
        x->cvdata.float32.knotcount = 0;
        x->cvdata.float32.stepcount = 0;
        x->cvdata.float32.spancount = 0;
        
        x->cvdata.float64.knots = NULL;
        x->cvdata.float64.knotcount = 0;
        x->cvdata.float64.stepcount = 0;
        x->cvdata.float64.spancount = 0;
        
        jit_functor_curve_cubicspline_setbasis(x, ps_jit_cubicspline_basisname_catmullrom);
        jit_functor_curve_cubicspline_recalc(x);
    }

    return (t_jit_object *)x;
}

t_jit_err jit_functor_curve_cubicspline_free(t_jit_functor_curve_cubicspline *x)
{
    if(x->cvdata.fixed.knots)
        jit_disposeptr((char*)x->cvdata.fixed.knots);
    x->cvdata.fixed.knots = NULL;
    
    if(x->cvdata.float32.knots)
        jit_disposeptr((char*)x->cvdata.float32.knots);
    x->cvdata.float32.knots = NULL;

    if(x->cvdata.float64.knots)
        jit_disposeptr((char*)x->cvdata.float64.knots);
    x->cvdata.float64.knots = NULL;

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_curve_cubicspline_resize(
    t_jit_functor_curve_cubicspline *x, long count)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x)
    {
        err = jit_functor_curve_cubicspline_resize_fixed(x, count);
        if(err) return err;

        err = jit_functor_curve_cubicspline_resize_float32(x, count);
        if(err) return err;

        err = jit_functor_curve_cubicspline_resize_float64(x, count);
        if(err) return err;
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_curve_cubicspline_resize_fixed(
    t_jit_functor_curve_cubicspline *x, long count)
{
    long i;
    long *newknots;
    long *oldknots;

    if(x)
    {
        // copy old knots
        if(x->cvdata.fixed.knots)
        {
            oldknots = x->cvdata.fixed.knots;
            newknots = (long*)jit_newptr(count * sizeof(long));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < x->cvdata.fixed.knotcount; i++)
                newknots[i] = oldknots[i];

            for(i = x->cvdata.fixed.knotcount; i < count; i++)
                newknots[i] = FloatToFixed(0.0f);

            jit_disposeptr((char*)x->cvdata.fixed.knots);
            x->cvdata.fixed.knots = NULL;

            x->cvdata.fixed.knots = newknots;
            x->cvdata.fixed.knotcount = count;
        }
        else
        {
            newknots = (long*)jit_newptr(count * sizeof(long));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < count; i++)
                newknots[i] = FloatToFixed(0.0f);

            x->cvdata.fixed.knots = newknots;
            x->cvdata.fixed.knotcount = count;
        }
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_curve_cubicspline_resize_float32(
    t_jit_functor_curve_cubicspline *x, long count)
{
    long i;
    float *newknots;
    float *oldknots;

    if(x)
    {
        // copy old knots
        if(x->cvdata.float32.knots)
        {
            oldknots = x->cvdata.float32.knots;
            newknots = (float*)jit_newptr(count * sizeof(float));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < x->cvdata.float32.knotcount; i++)
                newknots[i] = oldknots[i];

            for(i = x->cvdata.float32.knotcount; i < count; i++)
                newknots[i] = 0.0;

            jit_disposeptr((char*)x->cvdata.float32.knots);
            x->cvdata.float32.knots = NULL;

            x->cvdata.float32.knots = newknots;
            x->cvdata.float32.knotcount = count;
        }
        else
        {
            newknots = (float*)jit_newptr(count * sizeof(float));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < count; i++)
                newknots[i] = 0.0;

            x->cvdata.float32.knots = newknots;
            x->cvdata.float32.knotcount = count;
        }
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_curve_cubicspline_resize_float64(
    t_jit_functor_curve_cubicspline *x, long count)
{
    long i;
    double *newknots;
    double *oldknots;

    if(x)
    {
        // copy old knots
        if(x->cvdata.float64.knots)
        {
            oldknots = x->cvdata.float64.knots;
            newknots = (double*)jit_newptr(count * sizeof(double));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < x->cvdata.float64.knotcount; i++)
                newknots[i] = oldknots[i];

            for(i = x->cvdata.float64.knotcount; i < count; i++)
                newknots[i] = 0.0;

            jit_disposeptr((char*)x->cvdata.float64.knots);
            x->cvdata.float64.knots = NULL;

            x->cvdata.float64.knots = newknots;
            x->cvdata.float64.knotcount = count;
        }
        else
        {
            newknots = (double*)jit_newptr(count * sizeof(double));
            if(!newknots) return JIT_ERR_INVALID_PTR;

            for(i = 0; i < count; i++)
                newknots[i] = 0.0;

            x->cvdata.float64.knots = newknots;
            x->cvdata.float64.knotcount = count;
        }
    }

    return JIT_ERR_NONE;
}

/*
t_jit_err jit_functor_curve_cubicspline_setknot(
    t_jit_functor_curve_cubicspline *x, long index, double value)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x && index >= 0)
    {
        if(x->cvdata.float64.knots && index < x->cvdata.float64.knotcount)
        {
            x->cvdata.float64.knots[index] = (double)value;
        }
        else
        {
            // resize
            err = jit_functor_curve_cubicspline_resize(x, index);
            if(err) return err;

            // assign
            x->knots[index] = value;
        }
        return JIT_ERR_NONE;
    }

    // invalid pointer or index
    return JIT_ERR_GENERIC;
}
*/
t_jit_err jit_functor_curve_cubicspline_setknot_float32(
    t_jit_functor_curve_cubicspline *x, long index, float value)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x && index >= 0)
    {
        if(x->cvdata.float32.knots && index < x->cvdata.float32.knotcount)
        {
            x->cvdata.float32.knots[index] = value;
        }
        else
        {
            // resize
            err = jit_functor_curve_cubicspline_resize_float32(x, index);
            if(err) return err;

            // assign
            x->cvdata.float32.knots[index] = value;
        }
        return JIT_ERR_NONE;
    }

    // invalid pointer or index
    return JIT_ERR_GENERIC;
}

t_jit_err jit_functor_curve_cubicspline_setknot_float64(
    t_jit_functor_curve_cubicspline *x, long index, double value)
{
    t_jit_err err = JIT_ERR_NONE;

    if(x && index >= 0)
    {
        if(x->cvdata.float64.knots && index < x->cvdata.float64.knotcount)
        {
            x->cvdata.float64.knots[index] = value;
        }
        else
        {
            // resize
            err = jit_functor_curve_cubicspline_resize_float64(x, index);
            if(err) return err;

            // assign
            x->cvdata.float64.knots[index] = value;
        }
        return JIT_ERR_NONE;
    }

    // invalid pointer or index
    return JIT_ERR_GENERIC;
}

/*
t_jit_err jit_functor_curve_cubicspline_getknot(
    t_jit_functor_curve_cubicspline *x, long index, double *value)
{
    if(x && x->knots && index < x->knotcount && index >= 0 && value)
    {
        *value = x->knots[index];
        return JIT_ERR_NONE;
    }

    return JIT_ERR_INVALID_PTR;

}

t_jit_err jit_functor_curve_cubicspline_getknotcount(
    t_jit_functor_curve_cubicspline *x, long *count)
{
    if(x && count)
    {
        *count = x->knotcount;
        return JIT_ERR_NONE;
    }

    return JIT_ERR_INVALID_PTR;
}
*/

t_jit_err jit_functor_curve_cubicspline_setbasis(
    t_jit_functor_curve_cubicspline *x, t_symbol *name)
{
    long i, j;

    if(x && name)
    {
        if (x->basis != name) 
        {
            x->basis = name;
            jit_cubicspline_fillbasis_fixed(x->basis, &x->cvdata.fixed.matrix, &x->cvdata.fixed.stepcount);
            jit_cubicspline_fillbasis_float32(x->basis, &x->cvdata.float32.matrix, &x->cvdata.float32.stepcount);
            jit_cubicspline_fillbasis_float64(x->basis, &x->cvdata.float64.matrix, &x->cvdata.float64.stepcount);
            jit_functor_curve_cubicspline_recalc(x);
        }
        return JIT_ERR_NONE;
    }

    // invalid pointer or index
    return JIT_ERR_GENERIC;
}

t_jit_err jit_functor_curve_cubicspline_setattr_knots(
    t_jit_functor_curve_cubicspline *x, void *attr, long argc, t_atom *argv)
{
    long i;
    double v;
    t_jit_err err;

    if (x) {

        // allocate mem for knot array
        err = jit_functor_curve_cubicspline_resize_fixed(x, argc);
        if(err) return err;
        err = jit_functor_curve_cubicspline_resize_float32(x, argc);
        if(err) return err;
        err = jit_functor_curve_cubicspline_resize_float64(x, argc);
        if(err) return err;

        // copy all data values
        for(i = 0; i < argc; i++) {
            v = jit_atom_getfloat(argv + i);
            x->cvdata.fixed.knots[i] = DoubleToFixed(v);
            x->cvdata.float32.knots[i] = (float)v;
            x->cvdata.float64.knots[i] = (double)v;         
        }

        // recalc
        jit_functor_curve_cubicspline_recalc(x);

        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_curve_cubicspline_setattr_basis(
    t_jit_functor_curve_cubicspline *x, void *attr, long argc, t_atom *argv)
{
    t_symbol *v;

    if (x) {
        v = jit_atom_getsym(argv);
        jit_functor_curve_cubicspline_setbasis(x, v);
        return JIT_ERR_NONE;
    }
    return JIT_ERR_INVALID_PTR;
}

t_jit_err jit_functor_curve_cubicspline_recalc(t_jit_functor_curve_cubicspline *x)
{
    // calculate intermediary values for efficiency
    if(x->cvdata.fixed.stepcount > 0)
        x->cvdata.fixed.spancount = ((x->cvdata.fixed.knotcount - 1) / x->cvdata.fixed.stepcount) + 1;
    else
        x->cvdata.fixed.spancount = 0;

    if(x->cvdata.float32.stepcount > 0)
        x->cvdata.float32.spancount = ((x->cvdata.float32.knotcount - 1) / x->cvdata.float32.stepcount) + 1;
    else
        x->cvdata.float32.spancount = 0;

    if(x->cvdata.float64.stepcount > 0)
        x->cvdata.float64.spancount = ((x->cvdata.float64.knotcount - 1) / x->cvdata.float64.stepcount) + 1;
    else
        x->cvdata.float64.spancount = 0;

    return JIT_ERR_NONE;
}

// --------------------------------------------------------------------------
// vector evaluation functions
// --------------------------------------------------------------------------
long jit_functor_curve_cubicspline_eval_fixed(
    t_jit_functor_curve_cubicspline *x, long dimcount, long *vals)
{
    return jit_functor_eval_fixed_with_float64((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_sig)jit_functor_curve_cubicspline_eval_float64);
}

float jit_functor_curve_cubicspline_eval_float32(
    t_jit_functor_curve_cubicspline *x, long dimcount, float *vals)
{
    return jit_functor_eval_float32_with_scalar_product((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float32_scalar_sig)jit_functor_curve_cubicspline_eval_float32_scalar);
}

double jit_functor_curve_cubicspline_eval_float64(
    t_jit_functor_curve_cubicspline *x, long dimcount, double *vals)
{
    return jit_functor_eval_float64_with_scalar_product((t_jit_object *)x,dimcount,vals,
            (t_jit_functor_float64_scalar_sig)jit_functor_curve_cubicspline_eval_float64_scalar);
}

// --------------------------------------------------------------------------
// scalar evaluation functions
// --------------------------------------------------------------------------
long jit_functor_curve_cubicspline_eval_fixed_scalar(
    t_jit_functor_curve_cubicspline *x, long val)
{
    return jit_cubicspline_general_eval_fixed(
        val, x->cvdata.fixed.stepcount, x->cvdata.fixed.knotcount, 
        x->cvdata.fixed.knots, x->cvdata.fixed.matrix);
}

float jit_functor_curve_cubicspline_eval_float32_scalar(
    t_jit_functor_curve_cubicspline *x, float val)
{
    return jit_cubicspline_general_eval_float32(
        val, x->cvdata.float32.stepcount, x->cvdata.float32.knotcount, 
        x->cvdata.float32.knots, x->cvdata.float32.matrix);
}

double jit_functor_curve_cubicspline_eval_float64_scalar(
    t_jit_functor_curve_cubicspline *x, double val)
{
    return jit_cubicspline_general_eval_float64(
        val, x->cvdata.float32.stepcount, x->cvdata.float32.knotcount, 
        x->cvdata.float64.knots, x->cvdata.float64.matrix);
}
// --------------------------------------------------------------------------

Copyright © 2008, Cycling '74