SCV.h

#ifndef MTF_SCV_H
#define MTF_SCV_H

#include "SSDBase.h"

_MTF_BEGIN_NAMESPACE

struct SCVParams : AMParams{

    enum class HistType{ Dirac, Bilinear, BSpline };
    static const char* toString(HistType _hist_type);
    HistType hist_type;
    int n_bins;
    bool partition_of_unity;
    double pre_seed;
    // enable this to map each intensity to the weighted average of the two entries of the intensity map corresponding
    // to the floor and ceil of that intensity; if disabled it will be mapped to the entry corresponding to its floor 
    // leading to some information loss due to the fractional part that was discarded
    bool weighted_mapping;
    // enable this to automatically update the initial pixel gradient and hessian using the latest intensity map 
    // whenever the current pixel gradient is updated assuming that the current pixel values and thus the intensity map must
    // have changed since the last time the initial pixel gradient was computed;
    bool mapped_gradient;
    // decides if true SCV will be computed between the distance features; if it is turned off 
    // then the joint distribution will be 
    // computed from the two arguments to the distance functor itself after which the 
    // first argument will be mapped according to the expectation formula; note that 
    // using a KD tree index with this turned off will not produce the desired results because 
    // in that case this AM is no longer KD Tree compatible
    bool approx_dist_feat;
    bool debug_mode;

    SCVParams(const AMParams *am_params,
        HistType _hist_type, int _n_bins, double _pre_seed,
        bool _partition_of_unity, bool _weighted_mapping,
        bool _mapped_gradient, bool _approx_dist_feat,
        bool _debug_mode);
    SCVParams(const SCVParams *params = nullptr);
};

struct SCVDist : SSDBaseDist{
    typedef double ElementType;
    typedef double ResultType;
    SCVDist(const string &_name, const unsigned int _patch_size,
        const int _n_bins, const bool _approx_dist_feat);
    double operator()(const double* a, const double* b,
        size_t size, double worst_dist = -1) const override;
private:
    const unsigned int patch_size;
    const int n_bins;
    const bool approx_dist_feat;
};

class SCV : public SSDBase{
public:
    typedef SCVParams ParamType;
    typedef SCVDist DistType;
    typedef SCVParams::HistType HistType;

    SCV(const ParamType *scv_params = nullptr, const int _n_channels = 1);
    void initializePixVals(const Matrix2Xd& init_pts) override;
    void initializePixGrad(const Matrix2Xd &init_pts) override;
    void initializePixGrad(const Matrix8Xd &warped_offset_pts) override;

    void updatePixGrad(const Matrix2Xd &curr_pts) override;
    void updatePixGrad(const Matrix8Xd &warped_offset_pts) override;

    void updateSimilarity(bool prereq_only = true) override;

    void updatePixHess(const Matrix2Xd &curr_pts) override;
    using AppearanceModel::updatePixHess;
    const DistType* getDistFunc() override{
        return new DistType(name, patch_size, params.n_bins, params.approx_dist_feat);
    }

protected:

    ParamType params;

    cv::Mat init_img_cv;
    EigImgT init_img;
    VectorXd I0_orig;
    Matrix2Xd init_pts;
    Matrix8Xd init_warped_offset_pts;

    double hist_pre_seed;

    VectorXd intensity_map;

    // let A = err_vec_size = n_bins*n_bins and N = n_pix = no. of pixels
    MatrixXd curr_joint_hist;
    VectorXd init_hist, curr_hist;
    MatrixXd init_hist_mat, curr_hist_mat;

private:
    // only used internally to increase speed by offlining as many computations as possible;
    MatrixX2i _std_bspl_ids;
    MatrixX2i _init_bspl_ids;
    MatrixX2i _curr_bspl_ids;
    EigImgMat _init_img;
};

_MTF_END_NAMESPACE

#endif