tracking.cpp

Go to the documentation of this file.

#include "tracking.h"

//std::vector<CvPoint> Tracking::vecKalmanPoints;
//std::vector<KalmanFilter*> Tracking::vecKalmanObjects;

Tracking::Tracking() {
}

Tracking::~Tracking() {}

void Tracking::addKalmanPrediction(float x,float y) {
        vecKalmanPoints.push_back(cvPoint(x,y));
        KalmanFilter *addkalman=new KalmanFilter();
        vecKalmanObjects.push_back(addkalman);
        addkalman->predictionBegin(x,y);
        //addkalman->predictionUpdate(x,y);
        vecLastPointUpdate.push_back(cvPoint(x,y));
        CvPoint pre;
        addkalman->predictionGet(pre);
        vecKalmanPredicted.push_back(pre);
}
void Tracking::addKalmanPrediction(CBlob blob){
        double dWidth = blob.MaxX() - blob.MinX();
        double dHeight = blob.MaxY() - blob.MinY();
        float iCenterX=blob.MinX()+(dWidth/2);
        float iCenterY=blob.MinY()+(dHeight/2);
        addKalmanPrediction(iCenterX,iCenterY);
        /*vecKalmanBlobs.push_back(blob);
        KalmanFilter *addkalman=new KalmanFilter();
        vecKalmanObjects.push_back(addkalman);
        addkalman->predictionBegin(blob);
        vecLastBlobUpdate.push_back(blob);
        CvPoint pre;
        vecKalmanPredicted.push_back(pre);
        addkalman->predictionGet(pre);*/
}

void Tracking::updateKalmanPrediction(float x,float y,int i) {
        vecKalmanObjects[i]->predictionUpdate(x,y);
        vecLastPointUpdate[i]=cvPoint(x,y);
        vecKalmanObjects[i]->predictionGet(vecKalmanPredicted[i]);
}

void Tracking::updateKalmanPrediction(CBlob blob,int i){
        double dWidth = blob.MaxX() - blob.MinX();
        double dHeight = blob.MaxY() - blob.MinY();
        float iCenterX=blob.MinX()+(dWidth/2);
        float iCenterY=blob.MinY()+(dHeight/2);
        updateKalmanPrediction(iCenterX,iCenterY,i);
        /*vecKalmanObjects[i]->predictionUpdate(blob);
        vecLastBlobUpdate[i]=blob;
        vecKalmanObjects[i]->predictionGet(vecKalmanPredicted[i]);*/
}

void Tracking::clearKalman() {
        vecKalmanPoints.clear();
        //vecKalmanBlobs.clear();
        vecLastPointUpdate.clear();
        //vecLastBlobUpdate.clear();
        vecKalmanObjects.clear();
        vecKalmanPredicted.clear();
}

IplImage* Tracking::paintCrossKalmanSelected(IplImage* src) {
        //Length of cross
        int iCrossLen=10;
        //Color image
        IplImage *dst=getColorImage(src);
        //Paint Cross
        for(int i=0;i<vecKalmanPoints.size();i++) {
                CvPoint sel=vecKalmanPoints[i];
                cvLine( dst, cvPoint(sel.x-iCrossLen,sel.y),cvPoint(sel.x+iCrossLen,sel.y), CV_RGB(0,255,0),2,CV_AA);
                cvLine( dst, cvPoint(sel.x,sel.y-iCrossLen),cvPoint(sel.x,sel.y+iCrossLen), CV_RGB(0,255,0),2,CV_AA);
        }
        return dst;
}

IplImage* Tracking::paintCrossKalmanPredicted(IplImage* src) {
        //Length of cross
        int iCrossLen=5;
        //Color image
        IplImage *dst=getColorImage(src);
        //Paint Cross
        for(int i=0;i<vecKalmanPredicted.size();i++) {
                CvPoint pre=vecKalmanPredicted[i];
                cvLine( dst, cvPoint(pre.x-iCrossLen,pre.y),cvPoint(pre.x+iCrossLen,pre.y), CV_RGB(255,0,0),1,CV_AA);
                cvLine( dst, cvPoint(pre.x,pre.y-iCrossLen),cvPoint(pre.x,pre.y+iCrossLen), CV_RGB(255,0,0),1,CV_AA);
        }
        return dst;
}

IplImage* Tracking::paintCrossKalmanPredictedAutoUpdate(IplImage* src) {
        //Length of cross
        int iCrossLen=5;
        //Color image
        IplImage *dst=getColorImage(src);
        //Paint Cross and update prediction point
        for(int i=0;i<vecKalmanObjects.size();i++) {
                vecKalmanObjects[i]->predictionGet(vecKalmanPredicted[i]);
                CvPoint pre=vecKalmanPredicted[i];
                cvLine( dst, cvPoint(pre.x-iCrossLen,pre.y),cvPoint(pre.x+iCrossLen,pre.y), CV_RGB(255,0,0),1,CV_AA);
                cvLine( dst, cvPoint(pre.x,pre.y-iCrossLen),cvPoint(pre.x,pre.y+iCrossLen), CV_RGB(255,0,0),1,CV_AA);
        }
        return dst;
}

IplImage* Tracking::paintCrossKalmanPredictedLastUpdate(IplImage* src) {
        //Length of cross
        int iCrossLen=5;
        //Color image
        IplImage *dst=getColorImage(src);
        //Paint Cross and update prediction point
        for(int i=0;i<vecKalmanObjects.size();i++) {
                vecKalmanObjects[i]->predictionUpdate(vecLastPointUpdate[i].x,vecLastPointUpdate[i].y);
                vecKalmanObjects[i]->predictionGet(vecKalmanPredicted[i]);
                CvPoint pre=vecKalmanPredicted[i];
                cvLine( dst, cvPoint(pre.x-iCrossLen,pre.y),cvPoint(pre.x+iCrossLen,pre.y), CV_RGB(255,0,0),1,CV_AA);
                cvLine( dst, cvPoint(pre.x,pre.y-iCrossLen),cvPoint(pre.x,pre.y+iCrossLen), CV_RGB(255,0,0),1,CV_AA);
        }
        return dst;
}

std::vector<CvPoint> Tracking::getKalmanPoints(){
        return vecKalmanPoints;
}

/*std::vector<CBlob> Tracking::getKalmanBlobs(){
        return vecKalmanBlobs;
}*/

std::vector<CvPoint> Tracking::getKalmanPredicted(){
        //for(int i=0;i<vecKalmanPoints.size();i++)
        //      vecKalmanObjects[i]->predictionGet(vecKalmanPredicted[i]);
        return vecKalmanPredicted;
}
std::vector<CvPoint> Tracking::getLastPointUpdate(){
        return vecLastPointUpdate;
}

IplImage* Tracking::getColorImage(IplImage *src_image){
        if (cvGetElemType(src_image)==0){
                IplImage *dst=cvCreateImage( cvGetSize(src_image), 8, 3 );
                cvCvtColor( src_image, dst, CV_GRAY2BGR );
                cvReleaseImage(&src_image);
                return dst;
        }       else
                return src_image;
}

---