ParticleFilter.h

#ifndef PARTICLEFILTER_HEADER
#define PARTICLEFILTER_HEADER

#include "StrongClassifier.h"
#include "IntegralImage.h"
#include "MatchMatrix.h"

class ParticleFilter {
public:

    ParticleFilter(int n = 100, int szParticle = 2);

    ~ParticleFilter();

    void InitBuffer();

    void InitTarget(const Rect &target);

    void Propagate(const Size &imgSize);

    void Observe(const StrongClassifier *classifier, const IntegralImage *intImage);

    void Observe(const StrongClassifier *classifier, const IntegralImage *intImage,
        const Rect &detection, float detectionWeight);

    void ResampleWithBest();
    
    void ResampleWithConfidence();


    // Draw the particles.
    void DrawParticles(cv::Mat &img, const cv::Scalar &color) const;
    void DrawParticlesWithConfidence(cv::Mat &img, const cv::Scalar &color) const;

    // Draw the target;
    void DrawTarget(cv::Mat &img, const cv::Scalar &color) const;

    inline const Rect &GetTarget() const {
        return target;
    }

    inline void SetTarget(const Rect &t) {
        prevDets.push_back(t);
        if (prevDets.size() == 5) {
            prevDets.pop_front();
        }

        // Set the target size as the average of last four detections.
        int width = 0, height = 0;
        for (const auto &det : prevDets) {
            width += det.width;
            height += det.height;
        }

        target.width = width / prevDets.size();
        target.height = height / prevDets.size();
    }

protected:

    // The sizeof particles. Here it should be 2. Its structure like:
    // struct Particle {
    //      int upper;
    //      int left;
    // }
    const int numParticles;
    int *particles;
    const int sizeParticle;
    
    float *confidence;

    Rect target;

    std::deque<Rect> prevDets;

    // Seed.
    std::default_random_engine generator;

    // Gaussian random generator.
    std::normal_distribution<float> gaussian;

    // Uniform random generator.
    std::uniform_real_distribution<float> resampler;

    // A buffer used in resampling.
    int *resampleBuffer;

    // Binary search, used in resample.
    inline int BinarSearch(float prob) const {
        // A corner case.
        if (prob <= confidence[0])
            return 0;
        int start = 0;
        int end = numParticles - 1;
        int mid = (start + end) / 2;
        while (start < end - 1) {
            if (prob <= confidence[mid]) {
                end = mid;
            }
            else {
                start = mid;
            }
            mid = (start + end) / 2;
        }
        return end;
    }

    void InitParticles();

};

#endif