SingleTarget.h

#ifndef SINGLE_TARGET_HEADER
#define SINGLE_TARGET_HEADER

#define ST_DEBUG

#include "Options.h"
#include "StrongClassifierDirectSelect.h"
#include "ParticleFilterConstVelocity.h"
#include "MultiSampler.h"
#include "SingleSampler.h"

#define SINGLE_TARGET_VELOCITY_CONST 10.0f

class SingleTarget {
public:

    SingleTarget(const Options &ops);
    ~SingleTarget();

    void InitializeTarget(const Rect &target, const Point2D &initVelocity);

    void Propagate(const Size &imgSize);

    void Train(const IntegralImage *intImage, const MultiSampler *multiSampler, int id);

    inline void Train(const IntegralImage *intImage, const SingleSampler *sampler) {
        for (int i = 0; i < sampler->GetNumPos(); i++) {
            classifier->Update(intImage, sampler->GetPosSample(i), 1, 1.0f);
        }
        for (int i = 0; i < sampler->GetNumNeg(); i++) {
            classifier->Update(intImage, sampler->GetPosSample(i), -1, 1.0f);
        }
    }

    void CalculateMatchScore(const IntegralImage *intImage,
        const Pool<Rect> &dets,
        std::vector<MatchMatrix::MatchScore>::iterator &matchArray) const;

    bool CheckNearbyTarget(const Rect &det, int distThre) const;

    inline void Observe(const IntegralImage *intImage, const Rect &detection,
        float detectionWeight) {
        particleFilter->Observe(classifier, intImage, detection, detectionWeight);
    }

    inline void Observe(const IntegralImage *intImage) {
        particleFilter->Observe(classifier, intImage);
    }

    inline void UpdateSeq(bool isDetected) {
        detectionSeq >>= 1;
        if (isDetected)
            detectionSeq |= 0x08;
    }

    inline void ResampleWithBest() {
        particleFilter->ResampleWithBest();
    }

    inline void ResampleWithConfidence() {
        particleFilter->ResampleWithConfidence();
    }

    inline void DrawTarget(cv::Mat &img, const cv::Scalar &color) const {
        particleFilter->DrawTarget(img, color);
    }

    inline void DrawParticles(cv::Mat &img, const cv::Scalar &color) const {
        particleFilter->DrawParticles(img, color);
    }

    inline void DrawParticlesWithConfidence(cv::Mat &img, const cv::Scalar &color) const {
        particleFilter->DrawParticlesWithConfidence(img, color);
    }

    inline const Rect &GetTarget() const {
        return particleFilter->GetTarget();
    }

    inline void SetTarget(const Rect &t) {
        particleFilter->SetTarget(t);
    }

private:

    StrongClassifierDirectSelect *classifier;
    ParticleFilterConstVelocity *particleFilter;

    uchar detectionSeq;

    const float velocitySigmaConst;
};

#endif