blobtrackanalysishist.cpp

Program use openCV to demo edge detection (algorithm Gradient).

private:
    CvMemStorage*       m_pMem;
    int                 m_TrackNum;
    int                 m_Frame;
    char                m_DataFileName[1024];
    int                 m_Dim;
    float*              m_pFV;
    //CvStatModel*        m_pStatModel;
    void*               m_pStatModel;
    CvBlobSeq           m_Tracks;
    CvMat*              m_pTrainData;
    int                 m_LastTrainDataSize;
//    CvBlobTrackFVGen*   (*m_CreateFVGen)();
    CvBlobTrackFVGen*   m_pFVGen;
    float               m_NU;
    float               m_RBFWidth;
    IplImage*           m_pStatImg; /* for debug purpose */
    CvSize              m_ImgSize;
    void RetrainStatModel()
    {
///////// !!!!! TODO !!!!! Repair /////////////
#if 0        
        float               nu = 0;
        CvSVMModelParams    SVMParams = {0};
        CvStatModel*        pM = NULL;
        

        memset(&SVMParams,0,sizeof(SVMParams));
        SVMParams.svm_type = CV_SVM_ONE_CLASS;
        SVMParams.kernel_type = CV_SVM_RBF;
        SVMParams.gamma = 2.0/(m_RBFWidth*m_RBFWidth);
        SVMParams.nu = m_NU;
        SVMParams.degree = 3;
        SVMParams.criteria = cvTermCriteria(CV_TERMCRIT_EPS, 100, 1e-3 );
        SVMParams.C = 1;
        SVMParams.p = 0.1;
             

        if(m_pTrainData == NULL) return;
        {
            int64       TickCount = cvGetTickCount();
            printf("Frame: %d\n           Retrain SVM\nData Size = %d\n",m_Frame, m_pTrainData->rows);
            pM = cvTrainSVM( m_pTrainData,CV_ROW_SAMPLE, NULL, (CvStatModelParams*)&SVMParams, NULL, NULL);
            TickCount = cvGetTickCount() - TickCount ;
            printf("SV Count = %d\n",((CvSVMModel*)pM)->sv_total);
            printf("Processing Time = %.1f(ms)\n",TickCount/(1000*cvGetTickFrequency()));
            
        }
        if(pM==NULL) return;
        if(m_pStatModel) cvReleaseStatModel(&m_pStatModel);
        m_pStatModel = pM;
        
        if(m_pTrainData && m_Wnd)
        {
            float       MaxVal = 0;
            IplImage*   pW = cvCreateImage(m_ImgSize,IPL_DEPTH_32F,1);
            IplImage*   pI = cvCreateImage(m_ImgSize,IPL_DEPTH_8U,1);
            float*      pFVVar = m_pFVGen->GetFVVar();
            int     i;
            cvZero(pW);
            for(i=0;i<m_pTrainData->rows;++i)
            {/* draw all elements */
                float*          pFV = (float*)(m_pTrainData->data.ptr + m_pTrainData->step*i);
                int             x = cvRound(pFV[0]*pFVVar[0]);
                int             y = cvRound(pFV[1]*pFVVar[1]);
                float           r;

                if(x<0)x=0;
                if(x>=pW->width)x=pW->width-1;
                if(y<0)y=0;
                if(y>=pW->height)y=pW->height-1;

                r = ((float*)(pW->imageData + y*pW->widthStep))[x];
                r++;
                ((float*)(pW->imageData + y*pW->widthStep))[x] = r;

                if(r>MaxVal)MaxVal=r;
            }/* next point */
            if(MaxVal>0)cvConvertScale(pW,pI,255/MaxVal,0);
            cvNamedWindow("SVMData",0);
            cvShowImage("SVMData",pI);
            cvSaveImage("SVMData.bmp",pI);
            cvReleaseImage(&pW);
            cvReleaseImage(&pI);
        }/* prepare for debug */

        if(m_pStatModel && m_Wnd && m_Dim == 2)
        {
            float*      pFVVar = m_pFVGen->GetFVVar();
            int x,y;
            if(m_pStatImg==NULL)
            {
                m_pStatImg = cvCreateImage(m_ImgSize,IPL_DEPTH_8U,1);
            }
            cvZero(m_pStatImg);
            for(y=0;y<m_pStatImg->height;y+=1)for(x=0;x<m_pStatImg->width;x+=1)
            {/* draw all elements */
                float           res;
                uchar*  pData = (uchar*)m_pStatImg->imageData + x + y*m_pStatImg->widthStep;
                CvMat           FVmat;
                float           xy[2] = {x/pFVVar[0],y/pFVVar[1]};
                cvInitMatHeader( &FVmat, 1, 2, CV_32F, xy );
                res = cvStatModelPredict( m_pStatModel, &FVmat, NULL );
                pData[0]=((res>0.5)?255:0);
            }/* next point */
            cvNamedWindow("SVMMask",0);
            cvShowImage("SVMMask",m_pStatImg);
            cvSaveImage("SVMMask.bmp",m_pStatImg);
        }/* prepare for debug */
#endif
    };
    void SaveStatModel()
    {
        if(m_DataFileName[0])
        {
            if(m_pTrainData)cvSave(m_DataFileName, m_pTrainData);
        }
    };
    void LoadStatModel()
    {
        if(m_DataFileName[0])
        {
            CvMat* pTrainData = (CvMat*)cvLoad(m_DataFileName);
            if(CV_IS_MAT(pTrainData) && pTrainData->width == m_Dim)
            {
                if(m_pTrainData) cvReleaseMat(&m_pTrainData);
                m_pTrainData = pTrainData;
                RetrainStatModel();
            }
        }
    }
public:
    CvBlobTrackAnalysisSVM(CvBlobTrackFVGen*   (*createFVGen)()):m_Tracks(sizeof(DefTrackSVM))
    {
        m_pFVGen = createFVGen();
        m_Dim = m_pFVGen->GetFVSize();
        m_pFV = (float*)cvAlloc(sizeof(float)*m_Dim);
        m_Frame = 0;
        m_TrackNum = 0;
        m_pTrainData = NULL;
        m_pStatModel = NULL;
        m_DataFileName[0] = 0;
        m_pStatImg = NULL;
        m_LastTrainDataSize = 0;
        
        m_NU = 0.2f;
        AddParam("Nu",&m_NU);
        CommentParam("Nu","Parameters that tunes SVM border elastic");
        
        m_RBFWidth = 1;
        AddParam("RBFWidth",&m_RBFWidth);
        CommentParam("RBFWidth","Parameters that tunes RBF kernel function width.");

    }/* constructor */
    ~CvBlobTrackAnalysisSVM()
    {
        int i;
        SaveStatModel();
        for(i=m_Tracks.GetBlobNum();i>0;--i)
        {
            DefTrackSVM* pF = (DefTrackSVM*)m_Tracks.GetBlob(i-1);
            if(pF->pMem) cvReleaseMemStorage(&pF->pMem);
            //pF->pFVGen->Release();
        }
        if(m_pStatImg)cvReleaseImage(&m_pStatImg);
        cvFree(&m_pFV);
    }/* destructor */

    /*-----------------  interface --------------------*/
    virtual void    AddBlob(CvBlob* pBlob)
    {
        DefTrackSVM* pF = (DefTrackSVM*)m_Tracks.GetBlobByID(CV_BLOB_ID(pBlob));

        m_pFVGen->AddBlob(pBlob);

        if(pF == NULL)
        { /* create new record */
            DefTrackSVM F;
            F.state = 0;
            F.blob = pBlob[0];
            F.LastFrame = m_Frame;
            //F.pFVGen = m_CreateFVGen();
            F.pMem = cvCreateMemStorage();
            F.pFVSeq = cvCreateSeq(0,sizeof(CvSeq),sizeof(float)*m_Dim,F.pMem);
            
            F.BlobLast.x = -1;
            F.BlobLast.y = -1;
            F.BlobLast.w = -1;
            F.BlobLast.h = -1;
            m_Tracks.AddBlob((CvBlob*)&F);
            pF = (DefTrackSVM*)m_Tracks.GetBlobByID(CV_BLOB_ID(pBlob));
        }

        assert(pF);
        pF->blob = pBlob[0];
        pF->LastFrame = m_Frame;
    };
    virtual void Process(IplImage* pImg, IplImage* pFG)
    {
        int     i;
        float*  pFVVar = m_pFVGen->GetFVVar();
        
        m_pFVGen->Process(pImg, pFG);
        m_ImgSize = cvSize(pImg->width,pImg->height);

        for(i=m_pFVGen->GetFVNum();i>0;--i)
        {
            int             BlobID = 0;
            float*          pFV = m_pFVGen->GetFV(i,&BlobID);
            DefTrackSVM*    pF = (DefTrackSVM*)m_Tracks.GetBlobByID(BlobID);
            if(pF && pFV)
            {/* process */
                float   dx,dy;
                CvMat   FVmat;
                
                pF->state = 0;

                if(m_pStatModel)
                {
                    int j;
                    for(j=0;j<m_Dim;++j)
                    {
                        m_pFV[j] = pFV[j]/pFVVar[j];
                    }
                    cvInitMatHeader( &FVmat, 1, m_Dim, CV_32F, m_pFV );
                    //pF->state = cvStatModelPredict( m_pStatModel, &FVmat, NULL )<0.5;
                    pF->state = 1.f;
                }

                dx = (pF->blob.x - pF->BlobLast.x);
                dy = (pF->blob.y - pF->BlobLast.y);

                if(pF->BlobLast.x<0 || (dx*dx+dy*dy) >= 2*2)
                {   /* add feature vector to train data base */
                    pF->BlobLast = pF->blob;
                    cvSeqPush(pF->pFVSeq,pFV);
                }
            }/* process one blob */
        }/* next FV */

        for(i=m_Tracks.GetBlobNum();i>0;--i)
        {/* check each blob record */
            DefTrackSVM* pF = (DefTrackSVM*)m_Tracks.GetBlob(i-1);
            if(pF->LastFrame+3 < m_Frame )
            {/* retrain stat model and delete blob filter */
                int                 mult = 1+m_Dim;
                int                 old_height = m_pTrainData?m_pTrainData->height:0;
                int                 height = old_height + pF->pFVSeq->total*mult;
                CvMat*              pTrainData = cvCreateMat(height, m_Dim, CV_32F);
                int                 j;
                if(m_pTrainData && pTrainData)
                { /* create new train data matrix */
                    int h = pTrainData->height;
                    pTrainData->height = MIN(pTrainData->height, m_pTrainData->height);
                    cvCopy(m_pTrainData,pTrainData);
                    pTrainData->height = h;
                }
                for(j=0;j<pF->pFVSeq->total;++j)
                {/* copy new data to train data */
                    float*  pFVVar = m_pFVGen->GetFVVar();
                    float*  pFV = (float*)cvGetSeqElem(pF->pFVSeq,j);
                    int     k;
                    for(k=0;k<mult;++k)
                    {
                        int t;
                        float*  pTD = (float*)CV_MAT_ELEM_PTR( pTrainData[0], old_height+j*mult+k, 0);
                        memcpy(pTD,pFV,sizeof(float)*m_Dim);
                        
                        if(pFVVar)for(t=0;t<m_Dim;++t)
                        {/* scale FV */
                            pTD[t] /= pFVVar[t];
                        }

                        if(k>0)
                        {/* variate */
                            for(t=0;t<m_Dim;++t)
                            {
                                pTD[t] += m_RBFWidth*0.5f*(1-2.0f*rand()/(float)RAND_MAX);
                            }
                        }
                    }
                }/* next new data */

                if(m_pTrainData) cvReleaseMat(&m_pTrainData);
                m_pTrainData = pTrainData;

                /* delete track record */
                cvReleaseMemStorage(&pF->pMem);
                m_TrackNum++;
                m_Tracks.DelBlob(i-1);
            }/* end delete */
        }/* next track */

        /* retraind data each 1 minute if new data exist */
        if(m_Frame%(25*60) == 0 && m_pTrainData && m_pTrainData->rows > m_LastTrainDataSize)
        {
            RetrainStatModel();
        }

        m_Frame++;

        if(m_Wnd && m_Dim==2)
        {/* debug output */
            int         x,y;
            IplImage*   pI = cvCloneImage(pImg);

            if(m_pStatModel && m_pStatImg)
            for(y=0;y<pI->height;y+=2)
            {
                uchar*  pStatData = (uchar*)m_pStatImg->imageData + y*m_pStatImg->widthStep;
                uchar*  pData = (uchar*)pI->imageData + y*pI->widthStep;
                for(x=0;x<pI->width;x+=2)
                {/* draw all elements */
                    int d = pStatData[x];
                    d = (d<<8) | (d^0xff);
                    *(ushort*)(pData + x*3) = (ushort)d;
                }
            }/* next line */

            //cvNamedWindow("SVMMap",0);
            //cvShowImage("SVMMap", pI);
            cvReleaseImage(&pI);
        }/* debug output */
    };
    float GetState(int BlobID)
    {
        DefTrackSVM* pF = (DefTrackSVM*)m_Tracks.GetBlobByID(BlobID);
        return pF?pF->state:0.0f;
    };
    /* return 0 if trajectory is normal 
       return >0 if trajectory abnormal */
    virtual char*   GetStateDesc(int BlobID)
    {
        if(GetState(BlobID)>0.5) return "abnormal";
        return NULL;
    }
    virtual void    SetFileName(char* DataBaseName)
    {
        if(m_pTrainData)SaveStatModel();
        m_DataFileName[0] = 0;
        if(DataBaseName)
        {
            strncpy(m_DataFileName,DataBaseName,1000);
            strcat(m_DataFileName, ".yml");
        }
        LoadStatModel();
    };


    virtual void    Release(){ delete this; };

}; /* CvBlobTrackAnalysisSVM */


CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMP()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisSVM(cvCreateFVGenP);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPV()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisSVM(cvCreateFVGenPV);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMPVS()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisSVM(cvCreateFVGenPVS);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisSVMSS()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisSVM(cvCreateFVGenSS);}