blobtrackanalysishist.cpp

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

        {
            FreeData();
            m_BinNum = m_BinNumParam;
            AllocData();
        }
    }
public:
    CvBlobTrackAnalysisHist(CvBlobTrackFVGen*   (*createFVGen)()):m_TrackFGList(sizeof(DefTrackFG))
    {
        m_pFVGen = createFVGen();
        m_Dim = m_pFVGen->GetFVSize();
        m_Frame = 0;
        m_pFVi = 0;
        m_TrackNum = 0;
        m_BinNum = 32;
        m_DataFileName[0] = 0;

        m_AbnormalThreshold = 0.02f;
        AddParam("AbnormalThreshold",&m_AbnormalThreshold);
        CommentParam("AbnormalThreshold","If trajectory histogram value is lesst then <AbnormalThreshold*DataBaseTrackNum> then trajectory is abnormal");

        m_SmoothRadius = 1;
        AddParam("SmoothRadius",&m_SmoothRadius);
        CommentParam("AbnormalThreshold","Radius (in bins) for histogramm smothing");

        m_SmoothKernel = "L";
        AddParam("SmoothKernel",&m_SmoothKernel);
        CommentParam("SmoothKernel","L - Linear, G - Gaussian");


        m_BinNumParam = m_BinNum;
        AddParam("BinNum",&m_BinNumParam);
        CommentParam("BinNum","Number of bin for each dimention of feature vector");

        AllocData();
    }/* constructor */
    ~CvBlobTrackAnalysisHist()
    {
        SaveHist();
        FreeData();
        m_pFVGen->Release();
    }/* destructor */

    /*-----------------  interface --------------------*/
    virtual void    AddBlob(CvBlob* pBlob)
    {
        DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.GetBlobByID(CV_BLOB_ID(pBlob));
        if(pF == NULL)
        { /* create new filter */
            DefTrackFG F;
            F.state = 0;
            F.blob = pBlob[0];
            F.LastFrame = m_Frame;
//            F.pFVGen = m_CreateFVGen();
            F.pHist = new DefMat(m_Dim,m_Sizes,SPARSE);
            m_TrackFGList.AddBlob((CvBlob*)&F);
            pF = (DefTrackFG*)m_TrackFGList.GetBlobByID(CV_BLOB_ID(pBlob));
        }

        assert(pF);
        pF->blob = pBlob[0];
        pF->LastFrame = m_Frame;
        m_pFVGen->AddBlob(pBlob);
    };
    virtual void Process(IplImage* pImg, IplImage* pFG)
    {
        int i;
        m_pFVGen->Process(pImg, pFG);
        int SK = m_SmoothKernel[0];

        for(i=0;i<m_pFVGen->GetFVNum();++i)
        {
            int         BlobID = 0;
            float*      pFV = m_pFVGen->GetFV(i,&BlobID);
            float*      pFVMax = m_pFVGen->GetFVMax();
            float*      pFVMin = m_pFVGen->GetFVMin();
            DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.GetBlobByID(BlobID);
            int         HistVal = 1;

            if(pFV==NULL) break;

            pF->LastFrame = m_Frame;

            {/* binarize FV */
                int         j;
                for(j=0;j<m_Dim;++j)
                {
                    int     index;
                    float   f0 = pFVMin?pFVMin[j]:0;
                    float   f1 = pFVMax?pFVMax[j]:1;
                    assert(f1>f0);
                    index = cvRound((m_BinNum-1)*(pFV[j]-f0)/(f1-f0));
                    if(index<0)index=0;
                    if(index>=m_BinNum)index=m_BinNum-1;
                    m_pFVi[j] = index;
                }
            }

            HistVal = m_HistMat.GetVal(m_pFVi);/* get bin value*/
            pF->state = 0;
            { /* calc state */
                float   T = m_HistMat.m_Max*m_AbnormalThreshold; /* calc threshold */

                if(m_TrackNum>0) T = 256.0f * m_TrackNum*m_AbnormalThreshold;
                if(T>0)
                {
                    pF->state = (T - HistVal)/(T*0.2f) + 0.5f;
                }
                if(pF->state<0)pF->state=0;
                if(pF->state>1)pF->state=1;
            }

            {/* if new FV then add it to trajectory histogramm */
                int i,flag = 1;
                int r = m_SmoothRadius;
                
//                    printf("BLob %3d NEW FV [", CV_BLOB_ID(pF));
//                    for(i=0;i<m_Dim;++i) printf("%d,", m_pFVi[i]);
//                    printf("]");

                for(i=0;i<m_Dim;++i)
                {
                    m_pFViVar[i]=-r;
                }
                while(flag)
                {
                    float   dist = 0;
                    int     HistAdd = 0;
                    int     i;
                    int     good = 1;
                    for(i=0;i<m_Dim;++i)
                    {
                        m_pFViVarRes[i] = m_pFVi[i]+m_pFViVar[i];
                        if(m_pFViVarRes[i]<0) good= 0;
                        if(m_pFViVarRes[i]>=m_BinNum) good= 0;
                        dist += m_pFViVar[i]*m_pFViVar[i];
                    }/* calc next dimention */

                    if(SK=='G' || SK=='g')
                    {
                        double dist2 = dist/(r*r);
                        HistAdd = cvRound(256*exp(-dist2)); /* Hist Add for (dist=1) = 25.6*/
                    }
                    else if(SK=='L' || SK=='l')
                    {
                        dist = (float)(sqrt(dist)/(r+1));
                        HistAdd = cvRound(256*(1-dist));
                    }
                    else
                    {
                        HistAdd = 255; /* flat smothing */
                    }

                    if(good && HistAdd>0)
                    {/* update hist */
                        assert(pF->pHist);
                        pF->pHist->SetMax(m_pFViVarRes, HistAdd);
                    }/* update hist */

                    for(i=0;i<m_Dim;++i)
                    {/* next config */
                        if((m_pFViVar[i]++) < r)
                            break;
                        m_pFViVar[i] = -r;
                    }/* increase next dim var*/
                    if(i==m_Dim)break;
                }/* next variation */
            }/* if new FV */
        }/* next FV */
        
        {/* check all blob from list */
            int i;
            for(i=m_TrackFGList.GetBlobNum();i>0;--i)
            {/* add histogramm and delete blob from list */
                DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.GetBlob(i-1);
                if(pF->LastFrame+3 < m_Frame && pF->pHist)
                {
                    m_HistMat.Add(pF->pHist);
                    delete pF->pHist;
                    m_TrackNum++;
                    m_TrackFGList.DelBlob(i-1);
                }
            }/* next blob */
        }

        m_Frame++;

        if(m_Wnd)
        {/* debug output */
            int*        idxs = NULL;
            int         Val = 0;
            IplImage*   pI = cvCloneImage(pImg);
            
            cvZero(pI);
            for(Val = m_HistMat.GetNext(&idxs,1);idxs;Val=m_HistMat.GetNext(&idxs,0))
            {/* draw all elements */
                float   vf;
                int     x,y;

                if(!idxs) break;
                if(Val == 0) continue;

                vf = (float)Val/(m_HistMat.m_Max?m_HistMat.m_Max:1);
                x = cvRound((float)(pI->width-1)*(float)idxs[0] / (float)m_BinNum);
                y = cvRound((float)(pI->height-1)*(float)idxs[1] / (float)m_BinNum);

                cvCircle(pI, cvPoint(x,y), cvRound(vf*pI->height/(m_BinNum*2)),CV_RGB(255,0,0),CV_FILLED);
                if(m_Dim > 3)
                {
                    int dx = -2*(idxs[2]-m_BinNum/2);
                    int dy = -2*(idxs[3]-m_BinNum/2);
                    cvLine(pI,cvPoint(x,y),cvPoint(x+dx,y+dy),CV_RGB(0,cvRound(vf*255),1));
                }
                if( m_Dim==4 && 
                    m_pFVGen->GetFVMax()[0]==m_pFVGen->GetFVMax()[2] &&
                    m_pFVGen->GetFVMax()[1]==m_pFVGen->GetFVMax()[3])
                {
                    int x = cvRound((float)(pI->width-1)*(float)idxs[2] / (float)m_BinNum);
                    int y = cvRound((float)(pI->height-1)*(float)idxs[3] / (float)m_BinNum);
                    cvCircle(pI, cvPoint(x,y), cvRound(vf*pI->height/(m_BinNum*2)),CV_RGB(0,0,255),CV_FILLED);
                }
            }/* draw all elements  */

            for(i=m_TrackFGList.GetBlobNum();i>0;--i)
            {
                DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.GetBlob(i-1);
                DefMat* pHist = pF?pF->pHist:NULL;

                if(pHist==NULL) continue;

                for(Val = pHist->GetNext(&idxs,1);idxs;Val=pHist->GetNext(&idxs,0))
                {/* draw all elements */
                    float   vf;
                    int     x,y;

                    if(!idxs) break;
                    if(Val == 0) continue;

                    vf = (float)Val/(pHist->m_Max?pHist->m_Max:1);
                    x = cvRound((float)(pI->width-1)*(float)idxs[0] / (float)m_BinNum);
                    y = cvRound((float)(pI->height-1)*(float)idxs[1] / (float)m_BinNum);

                    cvCircle(pI, cvPoint(x,y), cvRound(2*vf),CV_RGB(0,0,cvRound(255*vf)),CV_FILLED);
                    if(m_Dim > 3)
                    {
                        int dx = -2*(idxs[2]-m_BinNum/2);
                        int dy = -2*(idxs[3]-m_BinNum/2);
                        cvLine(pI,cvPoint(x,y),cvPoint(x+dx,y+dy),CV_RGB(0,0,255));
                    }
                    if( m_Dim==4 && 
                        m_pFVGen->GetFVMax()[0]==m_pFVGen->GetFVMax()[2] &&
                        m_pFVGen->GetFVMax()[1]==m_pFVGen->GetFVMax()[3])
                    { /* if SS feature vector */
                        int x = cvRound((float)(pI->width-1)*(float)idxs[2] / (float)m_BinNum);
                        int y = cvRound((float)(pI->height-1)*(float)idxs[3] / (float)m_BinNum);
                        cvCircle(pI, cvPoint(x,y), cvRound(vf*pI->height/(m_BinNum*2)),CV_RGB(0,0,255),CV_FILLED);
                    }
                }/* draw all elements  */
            }/* next track */

            //cvNamedWindow("Hist",0);
            //cvShowImage("Hist", pI);
            cvReleaseImage(&pI);
        }
    };
    float GetState(int BlobID)
    {
        DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.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_HistMat.m_Volume!=m_HistVolumeSaved)SaveHist();
        m_DataFileName[0] = 0;
        if(DataBaseName)
        {
            strncpy(m_DataFileName,DataBaseName,1000);
            strcat(m_DataFileName, ".yml");
        }
        LoadHist();
    };
    virtual void SaveState(CvFileStorage* fs)
    {
        int b, bN = m_TrackFGList.GetBlobNum();
        cvWriteInt(fs,"BlobNum",bN);
        cvStartWriteStruct(fs,"BlobList",CV_NODE_SEQ);
        for(b=0;b<bN;++b)
        {
            DefTrackFG* pF = (DefTrackFG*)m_TrackFGList.GetBlob(b);
            cvStartWriteStruct(fs,NULL,CV_NODE_MAP);
            cvWriteStruct(fs,"Blob", &(pF->blob), "ffffi");
            cvWriteInt(fs,"LastFrame",pF->LastFrame);
            cvWriteReal(fs,"State",pF->state);
            pF->pHist->Save(fs, "Hist");
            cvEndWriteStruct(fs);
        }
        cvEndWriteStruct(fs);
        m_HistMat.Save(fs, "Hist");
    };
    virtual void LoadState(CvFileStorage* fs, CvFileNode* node)
    {
        CvFileNode* pBLN = cvGetFileNodeByName(fs,node,"BlobList");
        
        if(pBLN && CV_NODE_IS_SEQ(pBLN->tag)) 
        {
            int b, bN = pBLN->data.seq->total;
            for(b=0;b<bN;++b)
            {
                DefTrackFG* pF = NULL;
                CvBlob      Blob;
                CvFileNode* pBN = (CvFileNode*)cvGetSeqElem(pBLN->data.seq,b);
                
                assert(pBN);
                cvReadStructByName(fs, pBN, "Blob", &Blob, "ffffi");
                AddBlob(&Blob);
                pF = (DefTrackFG*)m_TrackFGList.GetBlobByID(Blob.ID);            
                if(pF==NULL) continue;
                assert(pF);
                pF->state = (float)cvReadIntByName(fs,pBN,"State",cvRound(pF->state));
                assert(pF->pHist);
                pF->pHist->Load(fs,pBN,"Hist");
            }
        }

        m_HistMat.Load(fs, node, "Hist");
    }; /* LoadState */


    virtual void    Release(){ delete this; };

};



CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistP()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisHist(cvCreateFVGenP);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPV()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisHist(cvCreateFVGenPV);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistPVS()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisHist(cvCreateFVGenPVS);}
CvBlobTrackAnalysis* cvCreateModuleBlobTrackAnalysisHistSS()
{return (CvBlobTrackAnalysis*) new CvBlobTrackAnalysisHist(cvCreateFVGenSS);}

typedef struct DefTrackSVM
{
    CvBlob                  blob;
//    CvBlobTrackFVGen*       pFVGen;
    int                     LastFrame;
    float                   state;
    CvBlob                  BlobLast;
    CvSeq*                  pFVSeq;
    CvMemStorage*           pMem;
} DefTrackSVM;

class CvBlobTrackAnalysisSVM : public CvBlobTrackAnalysis
{
    /*---------------- internal functions --------------------*/