amotseg.cpp

微软的基于HMM的人脸识别原代码, 非常经典的说

/*M///////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this license.
//  If you do not agree to this license, do not download, install,
//  copy or use the software.
//
//
//                        Intel License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of Intel Corporation may not be used to endorse or promote products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/

#include "CvTest.h"
#define PUSHC(Y,X) { CurStack[CStIn].y=Y; \
                     CurStack[CStIn].x=X; \
                     CStIn++;}
#define PUSHN(Y,X) { NextStack[NStIn].y=Y; \
                     NextStack[NStIn].x=X; \
                     NStIn++;}

#define POP(Y,X)  {	 CStIn--; \
    Y=CurStack[CStIn].y; \
    X=CurStack[CStIn].x;}

void testFill( float*    img,
               int       step,
               CvSize  imgSize,
               CvPoint seed_point,
               float     nv,
               float*    RP,
               int       itsstep,
			   float     SegThresh,
			   CvConnectedComp* region)
{
    CvPoint* CurStack = (CvPoint*)icvAlloc(imgSize.height*imgSize.width*sizeof(CvPoint));
    CvPoint* NextStack = (CvPoint*)icvAlloc(imgSize.height*imgSize.width*sizeof(CvPoint));
    CvPoint* Temp;
    int ownstep=step/4;
    int RPstep=itsstep/4;
    float thr = -SegThresh;
    float nthr = thr*2;
    int CStIn=0;
    int NStIn=0;
    int TempIn;
    int x,y;
	int XMax=0;
	int YMax=0;
	int XMin = imgSize.width;
	int YMin = imgSize.height;
	int Sum=0;
    
    PUSHC(seed_point.y,seed_point.x);
again:
    while(CStIn)
    {
        POP(y,x);
		XMax = MAX(XMax,x);
		YMax = MAX(YMax,y);
		XMin = MIN(XMin,x);
		YMin = MIN(YMin,y);
        if((y>0)&&(!RP[(y-1)*RPstep+x])&&
        (((img[(y-1)*ownstep+x]-img[y*ownstep+x])<0)&&
         ((img[(y-1)*ownstep+x]-img[y*ownstep+x])>=thr)))PUSHC(y-1,x);           
        if((y>0)&&(!RP[(y-1)*RPstep+x])&&
        (((img[(y-1)*ownstep+x]-img[y*ownstep+x])<=thr)&&
        ((img[(y-1)*ownstep+x]-img[y*ownstep+x])>=nthr)))PUSHN(y-1,x);
        if((y<imgSize.height-1)&&(!RP[(y+1)*RPstep+x])&&
        (((img[(y+1)*ownstep+x]-img[y*ownstep+x])<=0)&&
         ((img[(y+1)*ownstep+x]-img[y*ownstep+x])>=thr)))PUSHC(y+1,x);           
        if((y<imgSize.height-1)&&(!RP[(y+1)*RPstep+x])&&
        (((img[(y+1)*ownstep+x]-img[y*ownstep+x])<=thr)&&
        ((img[(y+1)*ownstep+x]-img[y*ownstep+x])>=nthr)))PUSHN(y+1,x);
        if((x>0)&&(!RP[y*RPstep+x-1])&&
        (((img[y*ownstep+x-1]-img[y*ownstep+x])<=0)&&
         ((img[y*ownstep+x-1]-img[y*ownstep+x])>=thr)))PUSHC(y,x-1);           
        if((x>0)&&(!RP[y*RPstep+x-1])&&
        (((img[y*ownstep+x-1]-img[y*ownstep+x])<=thr)&&
         ((img[y*ownstep+x-1]-img[y*ownstep+x])>=nthr)))PUSHN(y,x-1);
        if((x<imgSize.width-1)&&(!RP[y*RPstep+x+1])&&
        (((img[y*ownstep+x+1]-img[y*ownstep+x])<=0)&&
         ((img[y*ownstep+x+1]-img[y*ownstep+x])>=thr)))PUSHC(y,x+1);           
        if((x<imgSize.width-1)&&(!RP[y*RPstep+x+1])&&
        (((img[y*ownstep+x+1]-img[y*ownstep+x])<=thr)&&
         ((img[y*ownstep+x+1]-img[y*ownstep+x])>=nthr)))PUSHN(y,x+1);
		Sum++;
        RP[y*RPstep+x]=nv;
		img[y*ownstep+x] = -255;
    }
    if(NStIn)
    {
		Temp=CurStack;
		CurStack=NextStack;
		NextStack=Temp;
		TempIn=CStIn;
		CStIn=NStIn;
		NStIn=TempIn;
		goto again;
    }
	region->area = Sum;
    region->rect.x = XMin;
    region->rect.y = YMin;
    region->rect.width = XMax - XMin + 1;
    region->rect.height = YMax - YMin + 1;
    region->value = (float)nv;
    icvFree(&CurStack);
    icvFree(&NextStack);
    return;
}

/* Testing parameters */
static char TestName[] = "Checking MotionSegmentation";
static char TestClass[] = "Algorithm";
static int lImageWidth;
static int lImageHeight;
static int  Sobord;

static int  read_param = 0;
static int  data_types = 0;
static float thresh = 0;
static double EPSILON = 1.0001;


static int fcaMotSeg( void )
{
    int step;
    float* src;
	AtsRandState state; 
    double Error = 0;
	int color = 1;
	CvSize roi;

    IplImage* mhi;
    IplImage* mask32f;
	IplImage* test32f;
	CvSeq* seq1 = NULL;
	CvSeq* seq2 = NULL;
    CvMemStorage* storage;
	CvSeqWriter writer;
	
	CvConnectedComp ConComp;
	
    storage = cvCreateMemStorage( 0 );
    cvClearMemStorage( storage );

    /* Initialization global parameters */
    if( !read_param )
    {
        read_param = 1;
        /* Determining which test are needed to run */
        trsCaseRead( &data_types,"/u/s/f/a", "a",
                    "u - unsigned char, s - signed char, f - float, a - all" );
        /* Reading test-parameters */
        trsiRead( &lImageHeight, "20", "Image height" );
        trsiRead( &lImageWidth, "20", "Image width" );
        trssRead( &thresh, "10", "Segmentation Threshold" );
    }
    if( data_types != 3 && data_types != 0 ) return TRS_UNDEF;
    
    /* Creating images for testing */
    mhi = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
	mask32f = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);
	test32f = cvCreateImage(cvSize(lImageWidth, lImageHeight), IPL_DEPTH_32F, 1);

	atsRandInit(&state,40,100,60);
	atsFillRandomImageEx(mhi, &state );
	src = (float*)mhi->imageData;
	step = mhi->widthStep/4;
	for(int i=0; i<lImageHeight;i++)
	{
		for(int j=0; j<lImageWidth;j++)
		{
			if(src[i*step+j]>80)src[i*step+j]=80;
		}
	}
	iplSetFP(test32f,0);
	cvSegmentMotion(mhi,mask32f,storage,&seq1,80,thresh);
	cvStartWriteSeq( 0, sizeof( CvSeq ), sizeof( CvConnectedComp ), storage, &writer );
	roi.width = lImageWidth;
	roi.height = lImageHeight;
    for(i=1;i<lImageHeight-1;i++)
    {
        for(int j=1;j<lImageWidth-1;j++)
        {
            if(src[i*step+j]==80)
            {
				if((src[(i-1)*step+j]>=(80-thresh))&&(src[(i-1)*step+j]<80))
				{
					CvPoint MinPoint;
				    MinPoint.x=j;
					MinPoint.y=i-1;
					testFill(src,
							 step*4,
							 roi,
							 MinPoint,
							 (float)color,
							 (float*)test32f->imageData,
							 test32f->widthStep,
							 thresh,
							 &ConComp);
					ConComp.value = color;
					CV_WRITE_SEQ_ELEM( ConComp, writer );
					color+=1;
				}
				
				if((src[i*step+j-1]>=(80-thresh))&&(src[i*step+j-1]<80))
				{
					CvPoint MinPoint;
				    MinPoint.x=j-1;
					MinPoint.y=i;
					testFill(src,
							 step*4,
							 roi,
							 MinPoint,
							 (float)color,
							 (float*)test32f->imageData,
							 test32f->widthStep,
							 thresh,
							 &ConComp);
					ConComp.value = color;
					CV_WRITE_SEQ_ELEM( ConComp, writer );
					color+=1;
				}
				if((src[i*step+j+1]>=(80-thresh))&&(src[i*step+j+1]<80))
				{
					CvPoint MinPoint;
				    MinPoint.x=j+1;
					MinPoint.y=i;
					testFill(src,
							 step*4,
							 roi,
							 MinPoint,
							 (float)color,
							 (float*)test32f->imageData,
							 test32f->widthStep,
							 thresh,
							 &ConComp);
					ConComp.value = color;
					CV_WRITE_SEQ_ELEM( ConComp, writer );
					color+=1;
				}
				if((src[(i+1)*step+j]>=(80-thresh))&&(src[(i+1)*step+j]<80))
				{
					CvPoint MinPoint;
				    MinPoint.x=j;
					MinPoint.y=i+1;
					testFill(src,
							 step*4,
							 roi,
							 MinPoint,
							 (float)color,
							 (float*)test32f->imageData,
							 test32f->widthStep,
							 thresh,
							 &ConComp);
					ConComp.value = color;
					CV_WRITE_SEQ_ELEM( ConComp, writer );
					color+=1;
				}
				
            }   
         }
    }
    seq2 = cvEndWriteSeq( &writer );
	Error += iplNorm(test32f,mask32f,IPL_C);
	cvReleaseMemStorage(&storage);
	cvReleaseImage(&mhi);
	cvReleaseImage(&test32f);
	cvReleaseImage(&mask32f);
    /* Free Memory */
    
    if(Error>=EPSILON)return TRS_FAIL;
    return TRS_OK;
} /* fcaSobel8uC1R */

void InitAMotSeg(void)
{
    trsReg( "cvMotSeg", TestName, TestClass, fcaMotSeg);
} /* InitASobel */

/* End of file. */