CL_TimeWarp.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_TimeWarp.h ( Clip Library, C++)
 *
 * COMMENTS:
 * 
 */

#ifndef __CL_TimeWarp_h__
#define __CL_TimeWarp_h__

#include "CL_API.h"
#include <UT/UT_Matrix3.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_String.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_Vector3.h>

class UT_OStream;
class CL_Clip;
class CL_Track;

class CL_API CL_TimeWarp
{
public:
                     CL_TimeWarp();
    virtual         ~CL_TimeWarp();
    
    fpreal           linearWarp(fpreal sample, int warp_length);
    void             interpolateWarp();
    fpreal           warpSample(fpreal sample);
    bool             warpIsValid() { return myWarpIsValid; }
    int              warpLength() { return myWarpLength; }
    
    bool             setNumChannels(int num_channels,
                                    int src_channel_length, 
                                    int ref_channel_length);
     
    bool             addChannel(const fpreal *input_src_channel,
                                const fpreal *input_ref_channel);
    
    bool             addMotionChannels(const fpreal *src_tx_channel,
                                       const fpreal *src_ty_channel,
                                       const fpreal *src_tz_channel,
                                       const fpreal *ref_tx_channel,
                                       const fpreal *ref_ty_channel,
                                       const fpreal *ref_tz_channel);

    void             setRootTrnChannels(const fpreal *tx_channel,
                                        const fpreal *ty_channel,
                                        const fpreal *tz_channel,
                                        bool set_src);
    
    void             setRootRotChannels(const fpreal *rx_channel,
                                        const fpreal *ry_channel,
                                        const fpreal *rz_channel,
                                        bool set_src);

    void             processMotionChannels();

    fpreal*          srcChannel(int i)
                         { return mySrcChannels.get()+i*mySrcChannelLength; }
    fpreal*          refChannel(int i) 
                         { return myRefChannels.get()+i*myRefChannelLength; }

protected: 
    void             getRootTrnVec(int i, UT_Vector3R &vec, bool get_src);
    void             getRootRotVec(int i, UT_Vector3R &vec, bool get_src);
    void             getRootRotMat(int i, UT_Matrix3R &mat,
                                   UT_Matrix3R &inv_mat, bool get_src);

private:
    void             resetChannels();

protected:
    int                          myCurrentNumChannels;
    int                          myNumChannels;
    
    UT_Array<int>                myTrnChannels;

    UT_UniquePtr<fpreal[]>       myRefChannels;
    UT_UniquePtr<fpreal[]>       myRefRootTrnChannels[3];
    UT_UniquePtr<fpreal[]>       myRefRootRotChannels[3];
    int                          myRefChannelLength;

    UT_UniquePtr<fpreal[]>       mySrcChannels;
    UT_UniquePtr<fpreal[]>       mySrcRootTrnChannels[3];
    UT_UniquePtr<fpreal[]>       mySrcRootRotChannels[3];
    int                          mySrcChannelLength;

    bool                         myWarpIsValid;
    int                          myWarpLength;
    UT_UniquePtr<fpreal[]>       myWarpMap;
};

#endif