CL_Jiggle.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        CL_Jiggle.h ( Clip Library, C++)
 *
 * COMMENTS:
 *    Applies a jiggle filter to input data
 */


#ifndef __CL_Jiggle__
#define __CL_Jiggle__

#include "CL_API.h"
#include <SYS/SYS_Math.h>
#include <SYS/SYS_Types.h>
#include <UT/UT_DMatrix4.h>
#include <UT/UT_Vector3.h>

#include <algorithm>

class UT_Interrupt;

class CL_Jiggle
{
public:
    /// Solve for a jiggle filter given input data as an array of UT_Vector3D
    /// data and result must both be of length size
    template <typename T, typename F>
    static void solve(const UT_Vector3T<T> *data, UT_Vector3T<T> *result, int size, 
                      fpreal spring_constant, fpreal damping_constant,
                      fpreal limit, UT_Vector3T<T> multiplier,
                      const F& interrupt);

    // Overload for no-interrupt version
    template <typename T>
    static void solve(const UT_Vector3T<T> *data, UT_Vector3T<T> *result, int size,
                      fpreal spring_constant, fpreal damping_constant,
                      fpreal limit, UT_Vector3T<T> multiplier)
    {
        solve(data, result, size, 
              spring_constant, damping_constant, 
              limit, multiplier, []() { return false; });
    }

    /// Solve for a jiggle filter given input/output data as three separate arrays 
    /// for x,y,z components
    /// data and result must both be of length size
    template <typename T, typename F>
    static void solve(const fpreal *data_x, const fpreal *data_y, const fpreal *data_z,
                      fpreal *result_x, fpreal *result_y, fpreal *result_z, int size, 
                      fpreal spring_constant, fpreal damping_constant,
                      fpreal limit, UT_Vector3T<T> multiplier,
                      const F& interrupt, const UT_DMatrix4 *ref_xform = nullptr);

    // Overload for no-interrupt version
    template <typename T, typename F>
    static void solve(const fpreal *data_x, const fpreal *data_y, const fpreal *data_z,
                      fpreal *result_x, fpreal *result_y, fpreal *result_z, int size, 
                      fpreal spring_constant, fpreal damping_constant,
                      fpreal limit, UT_Vector3T<T> multiplier,
                      const UT_DMatrix4 *ref_xform = nullptr)
    {
        solve(data_x, data_y, data_z, result_x, result_y, result_z, size,
              spring_constant, damping_constant, limit, multiplier,
              [](){ return false; }, ref_xform);
    }

private:
    template<typename T>
    static UT_Vector3D spring(const UT_Vector3T<T> &current, fpreal spring, fpreal decay, 
                              const UT_Vector3T<T> &last, const UT_Vector3T<T> &vel)
    {
        return ((vel + (current - last) * spring) * (1.0 - decay));
    }

    template<typename T>
    static UT_Vector3T<T> simulate(UT_Vector3T<T> goal, fpreal k, fpreal d, fpreal limit,
                                   const UT_Vector3T<T> &multiplier, const UT_DMatrix4 *ref_xform,
                                   UT_Vector3T<T> &velocity, UT_Vector3T<T> &position)
    {
        UT_Vector3T<T> curr, last, vel, newvel, newpos, diff, local_pos;
        fpreal len, len2, limit2, f;

        curr = goal;
        last = position;
        vel = velocity;

        newvel = spring(curr, k, d, last, vel);
        newpos = last +  (newvel * 0.5);

        newvel = spring(curr, k, d, newpos, vel);
        vel = newvel;
        last += vel;

        diff = (curr - last);

        len = diff.length2();
        limit2 = limit * limit;

        if(len > limit2)
        {
            len = sqrt(len);
            len2 = 2.0 * limit - limit2 / len;
            f = 1.0 - len2/len;

            position = last + (diff * f);
            velocity = vel + (diff * f);
        }
        else
        {
            position = last;
            velocity = vel;
        }

        // Don't want to multiply position by ref_xform
        local_pos = position;

        if (ref_xform) 
        {
            local_pos *= (*ref_xform);
            goal *= (*ref_xform);
        }

        return (local_pos - goal) * multiplier + goal;
    }
};

template <typename T, typename F>
inline void 
CL_Jiggle::solve(const fpreal *data_x, const fpreal *data_y, const fpreal *data_z,
                 fpreal *result_x, fpreal *result_y, fpreal *result_z, int size, 
                 fpreal spring_constant, fpreal damping_constant,
                 fpreal limit, UT_Vector3T<T> multiplier,
                 const F& interrupt, const UT_DMatrix4 *ref_xform)
                 
{
    UT_Vector3T<T> goal, result_vec;
    UT_Vector3T<T> vel = { 0.0, 0.0, 0.0 };
    UT_Vector3T<T> pos = { data_x[0], data_y[0], data_z[0] };

    for (exint j = 0; j < size; j++)
    {    
        goal.assign(data_x[j], data_y[j], data_z[j]);
        result_vec = simulate(goal, spring_constant, damping_constant, limit, multiplier, 
                              (ref_xform == nullptr) ? nullptr : &(ref_xform[j]),
                              vel, pos);

        result_x[j] = result_vec.x();
        result_y[j] = result_vec.y();
        result_z[j] = result_vec.z();

        if (interrupt())
            return;
    }
}


template <typename T, typename F>
inline void
CL_Jiggle::solve(const UT_Vector3T<T> *data, UT_Vector3T<T> *result, int size, 
                 fpreal spring_constant, fpreal damping_constant,
                 fpreal limit, UT_Vector3T<T> multiplier,
                 const F& interrupt)
{
    UT_Vector3T<T> vel = { 0.0, 0.0, 0.0 };
    UT_Vector3T<T> pos = data[0];

    for (exint i = 0; i < size; i++) 
    {
        result[i] = simulate(data[i], spring_constant, damping_constant, limit, 
                             multiplier, nullptr,
                             vel, pos);

        if (interrupt())
            return;
    }
}

#endif