disparity 200712dlg.cpp

一个基于MFC的SIFT图像配准算法代码。好用

	double contArea, imgArea, maxRatio = 0.0;
	CvRect bndRect = cvRect(0,0,0,0);
	CvPoint pt1, pt2;
	float scaleFactor;
	CvScalar averageValue;
	int startCount = 0;
	int openCount = 0;
	int closedCount = 0;
	
	float openCompRatio = 0.0;
	float closedCompRatio = 0.0;
	float bestRatio = 0.0;
	imgArea = imgSize.width * imgSize.height;

//	 Open Template files
//  	openHandTmpl = cvLoadImage("openHandTmpl.jpg",1); 
//  	closedHandTmpl = cvLoadImage("closedHandTmpl.jpg",1); 
//  	// Convert form RGB to GRAY
//  	tmplSize.width = openHandTmpl->width;
//  	tmplSize.height = openHandTmpl->height;
//  	
//  	openGrayHandTmpl = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
//  	cvCvtColor( openHandTmpl, openGrayHandTmpl, CV_BGR2GRAY );
//  	
//  	tmplSize.width = closedHandTmpl->width;
//  	tmplSize.height = closedHandTmpl->height;
//  	
//  	closedGrayHandTmpl = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
//  	cvCvtColor( closedHandTmpl, closedGrayHandTmpl, CV_BGR2GRAY );
  
  // Generate processing images
	tmpImg = cvCloneImage(img);
	conv = cvCreateImage( imgSize, IPL_DEPTH_8U, 3);
	tmpH1 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	tmpS1 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	tmpH2 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	tmpS2 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	tmpH3 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	tmpS3 = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	H = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	S = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
	V = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);

	// Flip the image if in capture mode
	if ( capture )
	{
		cvFlip(conv, conv, 0);
	}


	// Image Smoothing
	//cvSmooth(img,tmpImg,CV_BLUR,3,3);
	cvSmooth(img,img,CV_GAUSSIAN,3,3);
//	printf("smooth image\n");

//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Convert to HSV
	cvCvtColor( tmpImg, conv, CV_BGR2HSV );
//	printf("smooth image\n");
//	cvShowImage("source",conv);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Split to HSV planes
	cvCvtPixToPlane(conv,H,S,V,0);
//	printf("H image\n");
//	cvShowImage("source",H);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
//	printf("S image\n");
//	cvShowImage("source",S);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
//	printf("V image\n");
//	cvShowImage("source",V);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Average Illumination
	averageValue = cvAvg( V , 0);
//	printf("average image\n");
//	cvShowImage("source",V);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	fprintf(output, "Illumination Level = %f\n", averageValue.val[0]);
	
	// Detect skin tone Hues and Saturations
	// NOTE: Hue values need to be doubled for actual
	
	// Red to Orange Hue with High Saturation
	// Hue 0 to 28 degree and Sat 190 to 200
	cvInRangeS(H,cvScalar(0.0,0.0,0,0),cvScalar(14.0,0.0,0,0),tmpH1);
//	printf("H in range image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvInRangeS(S,cvScalar(75.0,0.0,0,0),cvScalar(200.,0.0,0,0),tmpS1);
//	printf("S in range image\n");
//	cvShowImage("source",tmpS1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvAnd(tmpH1,tmpS1,tmpH1,0);
//	printf("and range image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Red Hue with Low Saturation
	// Hue 0 to 26 degree and Sat 20 to 90
	cvInRangeS(H,cvScalar(0.0,0.0,0,0),cvScalar(13.0,0.0,0,0),tmpH2); 
//	printf("H in range image\n");
//	cvShowImage("source",tmpH2);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvInRangeS(S,cvScalar(20.0,0.0,0,0),cvScalar(90.0,0.0,0,0),tmpS2);
//	printf("S in range image\n");
//	cvShowImage("source",tmpS2);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvAnd(tmpH2,tmpS2,tmpH2,0);
//	printf("and image\n");
//	cvShowImage("source",tmpH2);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Red Hue to Pink with Low Saturation
	// Hue 340 to 360 degree and Sat 15 to 90
	cvInRangeS(H,cvScalar(170.0,0.0,0,0),cvScalar(180.0,0.0,0,0),tmpH3);
//	printf("H in range image\n");
//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvInRangeS(S,cvScalar(15.0,0.0,0,0),cvScalar(90.,0.0,0,0),tmpS3);
//	printf("S in range image\n");
//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvAnd(tmpH3,tmpS3,tmpH3,0);
//	printf("and image\n");
//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Combine the Hue and Sat detections
	cvOr(tmpH3,tmpH2,tmpH2,0);
//	printf("or image\n");
//	cvShowImage("source",tmpH2);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	cvOr(tmpH1,tmpH2,tmpH1,0);
//	printf("or image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	

	// Dilation and Erosion
	
	// Structuring Element Generation
	dilationElement = cvCreateStructuringElementEx( 5,5,3,3, CV_SHAPE_RECT , 0 );
	erosionElement = cvCreateStructuringElementEx( 5,5,3,3, CV_SHAPE_RECT , 0 );
	
	// Dilation adds a layer on, and returns things to the correct size.
	cvDilate(tmpH1,tmpH2,dilationElement,1);
//	printf("dilate image\n");
//	cvShowImage("source",tmpH2);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Erosion peels a layer of pixels off, and makes small regions disappear
	cvErode(tmpH1,tmpH3,erosionElement,1);
//	printf("erode image\n");
//	cvShowImage("source",tmpH3);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// Find the contours of all remaining objects
	contour = 0;
	biggest = 0;
	cvFindContours( tmpH3, storage, &contour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
	cvZero(tmpH1);
//	printf("setzero image tempH1\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	
	// contour now contains a CvSequence of all of the contours
	for( ; contour != 0; contour = contour->h_next )
	{
		contArea = fabs(cvContourArea( contour, CV_WHOLE_SEQ ));
		
		// Ignore very small contours
		if ( contArea/imgArea >= 0.015 )
		{
			cvDrawContours( tmpH1, contour, color, color, 0, -1, 8 );
//	printf("draw contours image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			bndRect = cvBoundingRect( contour, 0 );
			
			// Scale the templates and result images
			scaleFactor = ((float)bndRect.width / (float)openHandTmpl->width);
			tmplSize.width = scaleFactor * openHandTmpl->width;
			tmplSize.height = scaleFactor * openHandTmpl->height;
			openscaledTmpl = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
			closedscaledTmpl = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
			openMatchResult = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
			closedMatchResult = cvCreateImage( tmplSize, IPL_DEPTH_8U, 1);
			cvResize( openGrayHandTmpl,openscaledTmpl, CV_INTER_LINEAR );
//	printf("resize opengrayhand image\n");
//	cvShowImage("source",openscaledTmpl);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			cvResize( closedGrayHandTmpl,closedscaledTmpl, CV_INTER_LINEAR );
//	printf("resize closedgrayhand image\n");
//	cvShowImage("source",closedscaledTmpl);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			
			// Set ROI for image
			bndRect.width = tmplSize.width;
			bndRect.height = tmplSize.height;
			cvSetImageROI(tmpH1, bndRect);
//	printf("set image roi image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			
			// Check that ROI matches the tmplate sizes
			// If the ROI is too near the edge og the image then the 
			// ROI may be truncated when it is set and will not match the bndRect
			if ( tmpH1->roi->width != bndRect.width || tmpH1->roi->height != bndRect.height )
			{
			}
			else
			{
				// Compare the Templates to the image ROI
				cvCmp( tmpH1,openscaledTmpl, openMatchResult, CV_CMP_EQ );
				cvCmp( tmpH1,closedscaledTmpl, closedMatchResult, CV_CMP_EQ );
			}
			
			// Analyze the results
			startCount = cvCountNonZero( tmpH1 );
//	printf("cvCoutNonZero(temH1) image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			openCount = cvCountNonZero( openMatchResult );
//	printf("cvCountNonZero( openMatchResult ) image\n");
//	cvShowImage("source",openMatchResult);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			closedCount = cvCountNonZero( closedMatchResult );
//	printf("cvCountNonZero( closedMatchResult ) image\n");
//	cvShowImage("source",closedMatchResult);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			
			openCompRatio = (float)openCount/(float)startCount;
			closedCompRatio = (float)closedCount/(float)startCount;
			bestRatio = 0.0;
			
			// Small regions may give eroneous results
			if ( openCompRatio > 1.0 ) openCompRatio = 0.0;
			if ( closedCompRatio > 1.0 ) closedCompRatio = 0.0;
			
			// Compare the Open and closed hand results
			if ( openCompRatio > closedCompRatio )
			{
				if ( openCompRatio > maxRatio )
				{
					maxRatio = openCompRatio;
					biggest = contour;
					isHandOpen = 1;
				}
			}
			else
			{
				if ( closedCompRatio > maxRatio )
				{
					maxRatio = closedCompRatio;
					biggest = contour;
					isHandOpen = 0;
				}
			}
			// Reset ROI 
			cvResetImageROI( tmpH1 );
//	printf("cvResetImageROI( tmpH1 ) image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
			
			// Output the results
			fprintf(output, "Contour Non-zero Count = %i\n", startCount);
			fprintf(output, "Open Hand Matched Non-zero Count   = %i Open Hand Ratio   = %f\n", openCount, openCompRatio);
			fprintf(output, "Clased Hand Matched Non-zero Count = %i Clased Hand Ratio = %f\n\n", closedCount, closedCompRatio);
			
#ifdef DEBUG
			cvShowImage("Comp Results1",openMatchResult);
			cvShowImage("Comp Results2",closedMatchResult);
			cvShowImage("Template1",openscaledTmpl);
			cvShowImage("Template2",closedscaledTmpl);
			cvShowImage("Skin Detection",tmpH1);
			cvWaitKey(0); 
#endif


		}
		cvZero(tmpH1);
//	printf("cvZero(tmpH1) image\n");
//	cvShowImage("source",tmpH1);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
	}
	
	// Draw Detection Rectangle
	// Red for Open Hand
	// Green for Closed Hand
	if ( biggest && maxRatio > 0.60 )
	{
		bndRect = cvBoundingRect( biggest, 0 );
		cvResetImageROI( img );
		pt1.x = bndRect.x;
		pt1.y = bndRect.y;
		pt2.x = bndRect.x + bndRect.width;
		pt2.y = bndRect.y + bndRect.height;
		
		if ( isHandOpen )
		{
			cvRectangle( img, pt1, pt2, CV_RGB(255,0,0), 5 );
//	printf("cvRectangle( img, pt1, pt2, CV_RGB(255,0,0), 5 ) image\n");
//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
		}
		else
		{
			cvRectangle( img, pt1, pt2, CV_RGB(0,255,0), 5 );
//	printf("cvRectangle( img, pt1, pt2, CV_RGB(0,255,0), 5 ) image\n");
//	cvShowImage("source",img);// added by liuzhi
//	cvWaitKey(0);// added by liuzhi
		}
	}
	
	// Display the results
	cvShowImage("Results",img);
	if(!capture)
		cvWaitKey(0);
	// If we found any contours then free the memory they use.
	if (contour!=NULL)
	{
		cvClearSeq(contour);
	}
	cvClearMemStorage(storage);
	cvReleaseImage(&tmpImg);
	cvReleaseImage(&conv);
	cvReleaseImage(&tmpH1);
	cvReleaseImage(&tmpS1);
	cvReleaseImage(&tmpH2);
	cvReleaseImage(&tmpS2);
	cvReleaseImage(&tmpH3);
	cvReleaseImage(&tmpS3);
	cvReleaseImage(&H);
	cvReleaseImage(&S);
	cvReleaseImage(&V);
	cvReleaseImage(&openscaledTmpl);
	cvReleaseImage(&closedscaledTmpl);
	cvReleaseImage(&openMatchResult);
	cvReleaseImage(&closedMatchResult);
}

void CDisparity200712Dlg::OnButton4() 
{
	
    
	IplImage	*m_pExImage;	
	CvCapture *capture  = cvCaptureFromFile("E:\\147.avi");
	
	if (capture == NULL)
	{
	/* Either the video didn't exist OR it uses a codec OpenCV
	* doesn't support.
		*/
		AfxMessageBox( "Error: Can't open video.");
		return ;
	}
	

	CString Path;

    int number_of_frames=1000;
	cvSetCaptureProperty( capture, CV_CAP_PROP_POS_AVI_RATIO, 1. );
	/* Now that we're at the end, read the AVI position in frames */
	number_of_frames = (int) cvGetCaptureProperty( capture, CV_CAP_PROP_POS_FRAMES );
    cvSetCaptureProperty( capture, CV_CAP_PROP_POS_FRAMES, 0. );
//	number_of_frames = (int) cvGetCaptureProperty( capture, CV_CAP_PROP_POS_FRAMES );
	m_pExImage = cvQueryFrame( capture );
	
	// char filename[1];
    char* filename2;
 	char* filename;
		CString name;
	for (int i=1; i<number_of_frames; i++)
	{
	
		m_pExImage = cvQueryFrame( capture );

     
	// 记录未经校正但平滑后(5*5)的图像
     filename2="f:\\MARS\\pic0.bmp";
	    name.Format("f:\\MARS\\pic%d.bmp", i);
//	name = Path + name;
//	cvSaveImage(name.operator LPCTSTR(), m_pExImage);
	     filename=(LPTSTR)LPCTSTR(name);   
		 //  strcpy(filename,name);
	 //  Path.Format("%s",filename);
//	  for   (int j=0;j<name.GetLength();j++)   
 //           filename[j]=(unsigned   char)name[j]; 
/*
		 filename[j]='.';
         filename[j+1]='j';
		 filename[j+2]='p';
		 filename[j+3]='g';
	//	 filename=filename+".jpg";*/
	  cvSaveImage(filename, m_pExImage);
      //name.Empty();
	}
}