UT_MinJerk.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:        UT_MinJerk.h ( UI Library, C++)
 *
 * COMMENTS:
 * 
 * MinJerk generates a curve that MINimimises the JERK of the movement. 
 * Ie a curve with as little acceleration change as possible. 
 * Using the constraints of the start and end positions, velocity, acceleration
 * and total travel time. 
 * 
 * It works typically well with positional values. 
 * But it can of course be used with any kind of data.
 * 
 * 
 * 
 * Typical usage would look something like this:
 * 
 * auto coefs = MinJerk_CalculateCoefficients(
 *          start_pos, end_pos,
 *          start_vel, end_vel,
 *          start_acc, end_acc,
 *          total_travel_time);
 * 
 * sample_time = min(sample_time, total_travel_time);
 * 
 * auto sample = MinJerkSample(coefs, sample_time);
 * 
 * sample.pos;
 * sample.vel;
 * sample.acc;
 * 
 * // To build a graph, do something like this.
 * UT_Array points;
 * for(float t=0; t<total_time; t+=time_step)
 * {
 *      auto sample = MinJerkSample(coefs, t);
 *      points.append(sample.pos);
 * }
 * 
 * 
 */

#ifndef __UT_MinJerk_h__
#define __UT_MinJerk_h__

#include <SYS/SYS_Math.h>

template <typename T>
struct UT_MinJerk_Result
{
    T pos;
    T vel;
    T acc;
};

template <typename T>
struct UT_MinJerk_ResultVec2
{
    UT_Vector2T<T> pos;
    UT_Vector2T<T> vel;
    UT_Vector2T<T> acc;
};

template <typename T>
struct UT_MinJerk_ResultVec3
{
    UT_Vector3T<T> pos;
    UT_Vector3T<T> vel;
    UT_Vector3T<T> acc;
};

template <typename T>
struct UT_MinJerk_ResultVec4
{
    UT_Vector4T<T> pos;
    UT_Vector4T<T> vel;
    UT_Vector4T<T> acc;
};


template <typename T>
void
MinJerk(
        const T pos0,
        const T vel0,
        const T acc0,
        const T pos1,
        const T vel1,
        const T acc1,
        const T sample_time,
        const T total_time,
        T& out_pos,
        T& out_vel,
        T& out_acc
        )
{
    if (total_time == 0.0)
    {
        return;
    }

    T tt = total_time;
    T tt2 = tt * tt;

    T a = pos0;
    T b = vel0 * tt;
    T c = acc0 * tt2 * 0.5;

    T pos = pos1 - pos0 - b - c;
    T vel = vel1 * tt - b - 2.0 * c;
    T acc = acc1 * tt2 - 2.0 * c;

    T d = ( 10.0 * pos) - (4.0 * vel) + (0.5 * acc);
    T e = (-15.0 * pos) + (7.0 * vel) - (1.0 * acc);
    T f = (  6.0 * pos) - (3.0 * vel) + (0.5 * acc);
    
    T t = sample_time / total_time;
    T t2 = t * t;
    T t3 = t2 * t;
    T t4 = t2 * t2;
    T t5 = t2 * t3;
    
    out_pos =  
        a + 
        b * t + 
        c * t2 + 
        d * t3 + 
        e * t4 + 
        f * t5;

    out_vel = (
        b + 
        c * 2.0 * t + 
        d * 3.0 * t2 + 
        e * 4.0 * t3 + 
        f * 5.0 * t4) * t;
    
    out_acc = (
        c * 2.0 + 
        d * 6.0 * t + 
        e * 12.0 * t2 + 
        f * 20.0 * t3) * t2;
}



template <typename T>
static UT_MinJerk_Result<T>
MinJerk(
        const T pos0,
        const T vel0,
        const T acc0,
        const T pos1,
        const T vel1,
        const T acc1,
        const T sample_time,
        const T total_time)
{
    UT_MinJerk_Result<T> out;
    MinJerk(pos0, vel0, acc0, pos1, vel1, acc1, sample_time, total_time, 
        out.pos, out.vel, out.acc);
    return out;
}

#define COLLECT_MINJERK_AXIS(I)                                                \
    MinJerk(pos0.I(), vel0.I(), acc0.I(), pos1.I(), vel1.I(), acc1.I(),        \
            sample_time, total_time,                                           \
            out.pos.I(), out.vel.I(), out.acc.I());

template <typename T>
static UT_MinJerk_ResultVec2<T>
MinJerk(
        const UT_Vector2T<T>& pos0,
        const UT_Vector2T<T>& vel0,
        const UT_Vector2T<T>& acc0,
        const UT_Vector2T<T>& pos1,
        const UT_Vector2T<T>& vel1,
        const UT_Vector2T<T>& acc1,
        const T sample_time,
        const T total_time
        )
{
    UT_MinJerk_ResultVec2<T> out;
    COLLECT_MINJERK_AXIS(x);
    COLLECT_MINJERK_AXIS(y);

    return out;
}

template <typename T>
static UT_MinJerk_ResultVec3<T>
MinJerk(
        const UT_Vector3T<T>& pos0,
        const UT_Vector3T<T>& vel0,
        const UT_Vector3T<T>& acc0,
        const UT_Vector3T<T>& pos1,
        const UT_Vector3T<T>& vel1,
        const UT_Vector3T<T>& acc1,
        const T sample_time,
        const T total_time)
{
    UT_MinJerk_ResultVec3<T> out;
    COLLECT_MINJERK_AXIS(x);
    COLLECT_MINJERK_AXIS(y);
    COLLECT_MINJERK_AXIS(z);

    return out;
}

template <typename T>
static UT_MinJerk_ResultVec4<T>
MinJerk(const UT_Vector4T<T>& pos0,
        const UT_Vector4T<T>& vel0,
        const UT_Vector4T<T>& acc0,
        const UT_Vector4T<T>& pos1,
        const UT_Vector4T<T>& vel1,
        const UT_Vector4T<T>& acc1,
        const T sample_time,
        const T total_time)
{
    UT_MinJerk_ResultVec4<T> out;
    COLLECT_MINJERK_AXIS(x);
    COLLECT_MINJERK_AXIS(y);
    COLLECT_MINJERK_AXIS(z);
    COLLECT_MINJERK_AXIS(w);

    return out;
}

#undef COLLECT_MINJERK_AXIS

#endif