testseq.cpp

Using open CV draw color histogram, convert RGB To HSI

            }

            if(p->pImgMask)
            {
                if(DirectCopy)
                    cvCopyImage(p->pImgMask, pImgMaskAdd);
                else
                    cvGetQuadrangleSubPix( p->pImgMask, pImgMaskAdd, pT);
                cvThreshold(pImgMaskAdd,pImgMaskAdd,128,255,CV_THRESH_BINARY);
            }

            if(pTrans->C != 1 || pTrans->I != 0)
            {/* intencity transformation */
                cvScale(pImgAdd, pImgAdd, pTrans->C,pTrans->I);
            }/* intencity transformation */

            if(pTrans->GN > 0)
            {/* add noise */
                IplImage* pImgN = cvCloneImage(pImgAdd);
                cvRandSetRange( &p->rnd_state, pTrans->GN, 0, -1 );
                cvRand(&p->rnd_state, pImgN);
                cvAdd(pImgN,pImgAdd,pImgAdd);
                cvReleaseImage(&pImgN);
            }/* add noise */

            if(p->Mask)
            {/* update only mask */
                cvOr(pImgMaskAdd, pImgMask, pImgMask);
            }
            else
            {   /* add image and mask to exist main image and mask */
                if(p->BG)
                {/* if image is background */
                    cvCopy( pImgAdd, pImg, NULL);
                }
                else
                {/* if image is foreground */
                    cvCopy( pImgAdd, pImg, pImgMaskAdd);
                    if(p->ObjID>=0)
                        cvOr(pImgMaskAdd, pImgMask, pImgMask);
                }
            }/* not mask */
        }/* for not noise */
        else
        {/* process noise video */

            if( p->noise_type == CV_NOISE_GAUSSIAN ||
                p->noise_type == CV_NOISE_UNIFORM)
            {/* gaussan and uniform additive noise */
                cvAddNoise(pImg,p->noise_type,pTrans->NoiseAmp * pTrans->C, &p->rnd_state);
            }/* gaussan and uniform additive noise */
            if( p->noise_type == CV_NOISE_SPECKLE)
            { /* speckle - multiplicative noise */
                if(pTrans->I != 0)cvSubS(pImg,cvScalar(pTrans->I,pTrans->I,pTrans->I),pImg);
                cvAddNoise(pImg,p->noise_type,pTrans->NoiseAmp, &p->rnd_state);
                if(pTrans->I != 0)cvAddS(pImg,cvScalar(pTrans->I,pTrans->I,pTrans->I),pImg);
            }/* speckle - multiplicative noise */
            if( p->noise_type == CV_NOISE_SALT_AND_PEPPER)
            { /* salt and pepper */
                cvAddNoise(pImg,p->noise_type,pTrans->NoiseAmp, &p->rnd_state);
            }/* speckle - multiplicative noise */
        }/* process noise video */
    }/* next item */

    if(pImg)
    {
        if(pTS->noise_type != CV_NOISE_NONE)
        {/* add noise */
            cvAddNoise(pImg,pTS->noise_type,pTS->noise_ampl);
        }
        if(pTS->IVar_DI != 0)
        {/* change intensity */
            float   I = MIN(pTS->IVar_CurI,pTS->IVar_MaxI);
            I = MAX(I,pTS->IVar_MinI);
            cvScale(pImg,pImg,1,I);

            if(pTS->IVar_CurI >= pTS->IVar_MaxI)
                pTS->IVar_CurDI = (float)-fabs(pTS->IVar_DI);
            if(pTS->IVar_CurI <= pTS->IVar_MinI)
                pTS->IVar_CurDI = (float)+fabs(pTS->IVar_DI);
            pTS->IVar_CurI += pTS->IVar_CurDI;
        }
    }


    pTS->CurFrame++;
    cvReleaseImage(&pImgAdd);
    cvReleaseImage(&pImgAddG);
    cvReleaseImage(&pImgMaskAdd);
    cvReleaseMat(&pT);
    return pImg;
}/*cvTestSeqQueryFrame*/

IplImage* cvTestSeqGetFGMask(CvTestSeq* pTestSeq)
{
    return ((CvTestSeq_*)pTestSeq)->pImgMask;
}
IplImage* cvTestSeqGetImage(CvTestSeq* pTestSeq)
{
    return ((CvTestSeq_*)pTestSeq)->pImg;
}

int cvTestSeqGetObjectNum(CvTestSeq* pTestSeq)
{
    //return ((CvTestSeq_*)pTestSeq)->ListNum;
    return ((CvTestSeq_*)pTestSeq)->ObjNum;
}

int cvTestSeqGetObjectPos(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pPos)
{
    CvTestSeq_*     pTS = (CvTestSeq_*)pTestSeq;
    CvTestSeqElem*  p = pTS->pElemList;
    if(pTS->CurFrame > pTS->FrameNum) return 0;
    for(p=pTS->pElemList;p;p=p->next)
    {
        int frame = pTS->CurFrame - p->FrameBegin - 1;
        if(ObjIndex==p->ObjID && frame >= 0 && frame < p->FrameNum) break;
    }
    if(p && p->pPos && p->PosNum>0)
    {
        CvTSTrans*  pTrans;
        float       t;
        int         frame = pTS->CurFrame - p->FrameBegin - 1;
        if(frame < 0 || frame >= p->FrameNum) return 0;
        t = (p->FrameNum>1)?((float)frame / (p->FrameNum-1)):0;
        pTrans = p->pTrans + frame%p->TransNum;
        pPos[0] = p->pPos[frame%p->PosNum];
#if 1 /* transform using T filed in Trans */
        {
            float x = pPos->x * (p->pImg?(p->pImg->width-1):1);
            float y = pPos->y * (p->pImg?(p->pImg->height-1):1);

            pPos->x = pTrans->T[0]*x+pTrans->T[1]*y+pTrans->T[2];
            pPos->y = pTrans->T[3]*x+pTrans->T[4]*y+pTrans->T[5];

            if(p->pImg)
            {
                pPos->x /= p->pImg->width-1;
                pPos->y /= p->pImg->height-1;
            }

        }


#else
        pPos->x = pPos->x * pTrans->Scale.x + pTrans->Shift.x;
        pPos->y = pPos->y * pTrans->Scale.y + pTrans->Shift.y;
#endif
        pPos->x *= pTS->pImg->width-1;
        pPos->y *= pTS->pImg->height-1;
        return 1;
    }
    return 0;
}/* cvTestSeqGetObjectPos */

int cvTestSeqGetObjectSize(CvTestSeq* pTestSeq, int ObjIndex, CvPoint2D32f* pSize)
{
    CvTestSeq_*     pTS = (CvTestSeq_*)pTestSeq;
    CvTestSeqElem*  p = pTS->pElemList;
    if(pTS->CurFrame > pTS->FrameNum) return 0;
    for(p=pTS->pElemList;p;p=p->next)
    {
        int frame = pTS->CurFrame - p->FrameBegin - 1;
        if(ObjIndex==p->ObjID && frame >= 0 && frame < p->FrameNum) break;
    }
    if(p && p->pSize && p->SizeNum>0)
    {
        CvTSTrans*  pTrans;
        float       t;
        int         frame = pTS->CurFrame - p->FrameBegin - 1;
        if(frame < 0 || frame >= p->FrameNum) return 0;
        t = (p->FrameNum>1)?((float)frame / (p->FrameNum-1)):0;
        pTrans = p->pTrans + frame%p->TransNum;
        pSize[0] = p->pSize[frame%p->SizeNum];
#if 1 /* transform using T filed in Trans */
        {
            float x = pSize->x * (p->pImg?(p->pImg->width-1):1);
            float y = pSize->y * (p->pImg?(p->pImg->height-1):1);
            float   dx1, dx2;
            float   dy1, dy2;

            dx1 = (float)fabs(pTrans->T[0]*x+pTrans->T[1]*y);
            dy1 = (float)fabs(pTrans->T[3]*x+pTrans->T[4]*y);

            dx2 = (float)fabs(pTrans->T[0]*x - pTrans->T[1]*y);
            dy2 = (float)fabs(pTrans->T[3]*x - pTrans->T[4]*y);

            pSize->x = MAX(dx1,dx2);
            pSize->y = MAX(dy1,dy2);

            if(p->pImg)
            {
                pSize->x /= p->pImg->width-1;
                pSize->y /= p->pImg->height-1;
            }

        }


#else
        pSize->x = pSize->x * pTrans->Scale.x;
        pSize->y = pSize->y * pTrans->Scale.y;
#endif
        pSize->x *= pTS->pImg->width-1;
        pSize->y *= pTS->pImg->height-1;
        return 1;
    }
    return 0;
}/* cvTestSeqGetObjectSize */

/* add noise to finile image */
void cvTestSeqAddNoise(CvTestSeq* pTestSeq, int noise_type, double noise_ampl)
{
    CvTestSeq_*     pTS = (CvTestSeq_*)pTestSeq;
    pTS->noise_type = noise_type;
    pTS->noise_ampl = noise_ampl;
}
/* add Intensity variation */
void cvTestSeqAddIntensityVariation(CvTestSeq* pTestSeq, float DI_per_frame, float MinI, float MaxI)
{
    CvTestSeq_* pTS = (CvTestSeq_*)pTestSeq;
    pTS->IVar_CurDI = pTS->IVar_DI = DI_per_frame;
    pTS->IVar_MaxI = MaxI;
    pTS->IVar_MinI = MinI;
}

void cvAddNoise(IplImage* pImg, int noise_type, double Ampl, CvRandState* rnd_state)
{/* add noise to image */
    CvSize      S = cvSize(pImg->width,pImg->height);
    IplImage*   pImgAdd = cvCreateImage(S,pImg->depth,pImg->nChannels);
    static CvRandState local_rnd_state;
    static int  first = 1;

    if(first)
    {
        first = 0;
        cvRandInit( &local_rnd_state, 1, 0, 0,CV_RAND_NORMAL);
    }
    if(rnd_state == NULL)rnd_state = &local_rnd_state;

    if( noise_type == CV_NOISE_GAUSSIAN ||
        noise_type == CV_NOISE_UNIFORM)
    {/* gaussan and uniform additive noise */
        int set_zero = 0;
        if( noise_type == CV_NOISE_GAUSSIAN)
        {
            rnd_state->disttype = CV_RAND_NORMAL;
            cvRandSetRange( rnd_state,  Ampl, 0, -1 );
            if(Ampl <= 0) set_zero = 1;
        }
        if( noise_type == CV_NOISE_UNIFORM)
        {
            double max_val =
                1.7320508075688772935274463415059 * Ampl;
            rnd_state->disttype = CV_RAND_UNI;
            cvRandSetRange( rnd_state, -max_val, max_val, -1 );
            if(max_val < 1) set_zero = 1;
        }
        if(!set_zero)
        {
            IplImage*   pImgNoise = cvCreateImage(S,IPL_DEPTH_32F,pImg->nChannels);
            IplImage*   pImgOrg = cvCreateImage(S,IPL_DEPTH_32F,pImg->nChannels);
            cvConvert(pImg, pImgOrg);
            cvRand(rnd_state, pImgNoise);
            cvAdd(pImgOrg,pImgNoise,pImgOrg);
            cvConvert(pImgOrg,pImg);
            cvReleaseImage(&pImgNoise);
            cvReleaseImage(&pImgOrg);
        }
    }/* gaussan and uniform additive noise */

    if( noise_type == CV_NOISE_SPECKLE)
    { /* speckle - multiplicative noise */
        IplImage* pImgSP = cvCreateImage( S,IPL_DEPTH_32F, pImg->nChannels );
        IplImage* pImgTemp = cvCreateImage(S,IPL_DEPTH_32F, pImg->nChannels );
        rnd_state->disttype = CV_RAND_NORMAL;
        cvRandSetRange( rnd_state, Ampl, 0, -1 );
        cvRand(rnd_state, pImgSP);
        cvConvert(pImg,pImgTemp);
        cvMul(pImgSP,pImgTemp,pImgSP);
        cvAdd(pImgTemp,pImgSP,pImgTemp);
        cvConvert(pImgTemp,pImg);
        cvReleaseImage(&pImgSP);
        cvReleaseImage(&pImgTemp);
    }/* speckle - multiplicative noise */

    if( noise_type == CV_NOISE_SALT_AND_PEPPER && Ampl > 0)
    { /* salt and pepper */
        IplImage* pImgMask = cvCreateImage( S,IPL_DEPTH_32F, 1 );
        IplImage* pImgMaskBin = cvCreateImage( S,IPL_DEPTH_8U, 1 );
        IplImage* pImgVal = cvCreateImage( S,IPL_DEPTH_8U, 1 );
        rnd_state->disttype = CV_RAND_UNI;
        /* create mask */
        cvRandSetRange( rnd_state, 0, 1, -1 );
        cvRand(rnd_state, pImgMask);
        cvThreshold(pImgMask,pImgMask, Ampl, 255, CV_THRESH_BINARY_INV );
        cvConvert(pImgMask,pImgMaskBin);
        /* create vals */
        cvRandSetRange( rnd_state, 0, 255, -1 );
        cvRand(rnd_state, pImgVal);
        cvThreshold(pImgVal,pImgVal,128, 255, CV_THRESH_BINARY );
        cvMerge(
            pImgAdd->nChannels>0?pImgVal:NULL,
            pImgAdd->nChannels>1?pImgVal:NULL,
            pImgAdd->nChannels>2?pImgVal:NULL,
            pImgAdd->nChannels>3?pImgVal:NULL,
            pImgAdd);
        cvCopy(pImgAdd, pImg, pImgMaskBin);
        cvReleaseImage(&pImgMask);
        cvReleaseImage(&pImgMaskBin);
        cvReleaseImage(&pImgVal);
    }/* speckle - multiplicative noise */
    cvReleaseImage(&pImgAdd);
}/* cvAddNoise */