GU_MotionClipSalientPoses.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:        GU_MotionClipSalientPoses.h ( GU Library, C++)
 *
 * COMMENTS:    Finds salient poses from a motion clip.
 * 
 */

#ifndef __GU_MOTIONCLIPSALIENTPOSES_H__
#define __GU_MOTIONCLIPSALIENTPOSES_H__

#include "GU_API.h"

#include "GU_DetailHandle.h"
#include "GU_MotionClip.h"

#include <UT/UT_Interrupt.h>
#include <UT/UT_String.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_ValArray.h>
#include <UT/UT_WorkBuffer.h>

class GU_API GU_MotionClipSalientPoses
{
public:

    enum class Method
    {
        MinFrame = 0,
        MinJoint = 1,
        MinAvg   = 2
    };

                     GU_MotionClipSalientPoses();
    virtual         ~GU_MotionClipSalientPoses();
    
    int              getKeySample(int key);
    fpreal           getKeyTime(int key);
    bool             isPoseKeyed(int pose);

    bool             keyMapIsValid() { return myKeyMapIsValid; }
    int              keyMapLength() { return myKeyMapLength; }
    fpreal           keyMapError() { return myKeyMapError; }

    int              numPoses() { return myNumPoses; }

    bool             initializeChannels(UT_Array<GU_Detail> &clip,
                                        UT_Array<fpreal> &pose_times,
                                        int num_poses,
                                        UT_WorkBuffer &err_msg);
    bool             computeWeights(bool use_max_step,
                                    int max_step,
                                    UT_WorkBuffer &err_msg);
    void             computeKeys(int num_keys,
                                 bool reduce_past_target,
                                 fpreal tolerance,
                                 GU_MotionClipSalientPoses::Method weight_method,
                                 UT_WorkBuffer &error_msg);
    
private:
    
    class PairWeight
    {
        public:
            fpreal worst_pose;
            fpreal worst_joint;
            fpreal pose_sum;
    };
    class KeyPath
    {
        public:
            fpreal worst_pose;
            fpreal worst_joint;
            fpreal pose_sum;
            int    key;
    };

    void        resetArrays();

    void        unboundMaxStep();
    bool        boundMaxStep(int max_step);
    
    bool        initializeJointArrays(GU_Detail *frame_gdp,
                                      UT_WorkBuffer &err_msg);

    bool        setPoseInfo(UT_Array<fpreal> &pose_times, int num_poses,
                            UT_WorkBuffer &err_msg);
    UT_Matrix4R combineLocal(const UT_Matrix4R &L,
                             const UT_Matrix4R &pW,
                             const UT_Matrix3R &pLS,
                             const UT_Matrix3R &pLS_inv,
                             UT_ScaleInheritanceMode mode,
                             bool stretch_is_diag,
                             UT_Matrix3R *LS);
    bool        computePairWeight(int start_sample, int end_sample);
    
    bool        isCandidatePathShorter(const KeyPath &path,
                                       const PairWeight &cand);
    bool        computeShortestPaths(int num_keys, UT_AutoInterrupt &boss);

    fpreal      computePathError(int keys_before);
    int         findOptimalKeyMap(int max_keys, fpreal tolerance);
    void        computeKeyMap(int num_keys);
    
    KeyPath             &getShortPath(int end_sample, int keys_before);
    PairWeight          &getWeight(int start_sample, int end_sample);
    UT_Vector3R         *getPosChannel(int sample);
    UT_Vector3R         *getTrnChannel(int sample);
    UT_Quaternion       *getRotChannel(int sample);
    UT_Matrix3R         *getStretchChannel(int sample);
    
private:
    // Pose Varaibles
    int                          myNumPoses;
    UT_Array<fpreal>             myPoseTimes;
    UT_Array<bool>               myPoseIsKeyed;

    // Joint Variables
    int                          myNumJoints;
    GA_OffsetArray               myJointOffsets;
    UT_IntArray                  myParents;

    UT_Array<bool>               myDoComputeLocalScale;
    UT_IntArray                  myScaleInheritance;
    
    UT_UniquePtr<UT_Vector3R[]>    myPosChannels;
    UT_UniquePtr<UT_Vector3R[]>    myTrnChannels;
    UT_UniquePtr<UT_Quaternion[]>  myRotChannels;
    UT_UniquePtr<UT_Matrix3R[]>    myStretchChannels;
    UT_Array<bool>                 myStretchIsDiag;

    // Weight Variables
    bool                         myMaxStepIsBounded;
    int                          myMaxStep;
    int                          myMaxComputedStep;

    GU_MotionClipSalientPoses::Method  myWeightMethod;
    UT_Array<PairWeight>               myFramePairWeight;
    
    // Path Variables
    int                          myNumKeysComputed;

    UT_Array<KeyPath>            myShortPaths;

    // Key Map Variables
    bool                         myKeyMapIsValid;
    int                          myKeyMapLength;
    fpreal                       myKeyMapError;
    UT_Array<int>                myKeyMap;
};

#endif