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

#ifndef __CL_GuidedTimeWarp_h__
#define __CL_GuidedTimeWarp_h__

#include "CL_API.h"
#include <UT/UT_String.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_WorkBuffer.h>

#include "CL_TimeWarp.h"

class UT_OStream;
class CL_Clip;
class CL_Track;

class CL_API CL_GuidedTimeWarp : public CL_TimeWarp
{
public:

     CL_GuidedTimeWarp();
     ~CL_GuidedTimeWarp() override;

    void             warpClip(fpreal src_fps,
                              fpreal ref_fps,
                              int max_step,
                              int warp_length,
                              int knn,
                              fpreal path_length_weight,
                              bool use_warp_length,
                              UT_WorkBuffer &error_msg);

private:
   
    void             computeMotionVector(bool get_src,
                                         int i, int j, int k,
                                         fpreal *feature_vec);
    void             computeRefMotionVectors();
    
    void             initSmallestK(fpreal *smallest, int k);
    void             updateSmallestK(fpreal *smallest, int k, fpreal candidate);
    fpreal           averageSmallestK(fpreal *smallest, int k);

    bool             computeWeightFn();
    fpreal           computeRootWeight(fpreal *src_motion_vec, int f, int j);
    void             computeAverageWeight();

    bool             computeShortestPaths();
    void             findShortestPathLength(fpreal path_len_weight);
    
    void             computeWarpMap();

    fpreal          *getRefMotionVector(int f);
    fpreal           &getWeightFn(int f0, int f1, int f2);
    
    class WarpPath
    {        
    public:
            fpreal weight;
            int    prev;
    };
    WarpPath         &getShortPath(int warped_frame, int f0, int f1)
    {
        int index = warped_frame*myNumNodes
                    + f0*myMaxStep
                    + (f1-f0-1);
        return myShortPaths[index];
    }
    
private:
    fpreal                       myRefFPS;
    fpreal                       mySrcFPS;
    
    fpreal64                     myAverageWeight;

    int                          myMaxStep;
    int                          myKNearestNeighbours;

    int                          myNumNodes;
    int                          myNumEdges;
    UT_UniquePtr<fpreal[]>       myRefMotionVectors;
    UT_UniquePtr<fpreal[]>       myWeightFn;
    UT_UniquePtr<WarpPath[]>         myShortPaths;
};

#endif