The Learning of OpenCV

Here contains just the exercises in book "Learning OpenCV" and of course I believe there is better solution for them.

Actually some of simple test is NOT from the book and it is my own playing.

// I try to compare the result between DCT and DFT cause simply don't understand them at all.

#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <windows.h>
#include <tchar.h>
#include <time.h>

#pragma comment(lib, "cvd.lib")
#pragma comment(lib, "cxcored.lib")
#pragma comment(lib, "highguid.lib")

#pragma message("hello")

void exercise28()
{
	char* szWinName[] = {"original",  "polar"};
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	int i = 0, j = 0;
	double color = 255.0;
	int nWidth = 640, nHeight = 480;
	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_8U, 3);
			for (j = 4; j < 8; j ++ )
			{
				cvRectangle(pImage[i], cvPoint(nWidth/j, nHeight/j), cvPoint(nWidth*(j-1)/j, nHeight*(j-1)/j), cvScalar(0, 0, 255), 4);
			}
		
			break;
		default:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, pImage[0]->nChannels);
			cvLogPolar(pImage[0], pImage[i], cvPoint2D32f(pImage[0]->width/2.0, pImage[0]->height/2.0), 50.0);
			break;
		}
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}

}

void exercise29()
{
	char* szWinName[] = {"original", "red", "green", "blue", "realpart Red", "realpart Green", 
		"realpart Blue", "DCT red", "DCT green", "DCT blue", 
	"DFT red", "DFT green", "DFT blue", };
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	IplImage* pTotalImg = NULL;
	int i = 0, j = 0;
	int nPixSize = 3;
	CvMat myMat;
	char* pRow = NULL, *pSrc = NULL, *pDst = NULL;

	CvMat* pMat[4] = {NULL};
	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvLoadImage("mytest.bmp");	
			nPixSize = pImage[0]->depth*pImage[0]->nChannels/8;
			//pTotalImg = cvCreateImage(cvSize(pImage[0]->width*nNumber, pImage[0]->height), pImage[0]->depth, pImage[0]->nChannels);
			//cvNamedWindow("total");		
				
			pImage[1] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);			
		
			pImage[2] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);			
	
			pImage[3] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);				
			cvSplit(pImage[0], pImage[3], pImage[2], pImage[1], NULL);
			break;
		case 4: 
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);			
			cvZero(pImage[i]);
			cvConvertScale(pImage[1], pImage[i], 1.0/255);
			break;
		case 5:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[2], pImage[i], 1.0/255.0);
			break;
		case 6:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[3], pImage[i], 1.0/255.0);
			break;
		case 7:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);				
			cvDCT(pImage[4], pImage[i], CV_DXT_FORWARD);		
			break;
		case 8:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[5], pImage[i], CV_DXT_FORWARD);	
			break;
		case 9:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[6], pImage[i], CV_DXT_FORWARD);	
			break;
		/*
		case 10:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[7], pImage[i],255);
			break;
		case 11:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[8], pImage[i]);
			break;
		case 12:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[9], pImage[i]);
			break;
			*/
		case 10:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDFT(pImage[4], pImage[i], CV_DXT_FORWARD, pImage[i]->height);		
			break;
		case 11:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDFT(pImage[5], pImage[i], CV_DXT_FORWARD, pImage[i]->height);	
			break;
		case 12:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDFT(pImage[6], pImage[i], CV_DXT_FORWARD, pImage[i]->height);	
			break;
			/*
		case 16:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[13], pImage[i],255);
			break;
		case 17:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[14], pImage[i]);
			break;
		case 18:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_8U, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[15], pImage[i]);
			break;
			*/
		}	
		
		
		/*
		pSrc = pImage[i]->imageData;
		pDst = pTotalImg->imageData + i*pImage[0]->width*nPixSize;
		for (j = 0; j < pImage[0]->height; j ++)
		{
			memcpy(pDst, pSrc, pImage[0]->width*nPixSize);
			pSrc += pImage[0]->widthStep;
			pDst += pTotalImg->widthStep;
		}
		*/
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	//cvShowImage("total", pTotalImg);
	
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}
}



int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{	
	exercise29();
	return 0;
}

///////////////////////////////////////////////////////////////////////////////////////

// this is slightly different from above as I am trying to verify that DFT/DCT are indeed inversable operations. This is arsing from my mis-understanding about jpeg which is a lossy compression. The 

//DCT/DFT part operation is not lossy. It is at quantization after DCT/DFT. Also I am trying to compare DFT/Convolution fast algorithms with original convolution or cvFilter2D. But it is just half done.

// I need to copy the sample code from book regarding the DFT/Convolution.

#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <windows.h>
#include <tchar.h>
#include <time.h>

#pragma comment(lib, "cvd.lib")
#pragma comment(lib, "cxcored.lib")
#pragma comment(lib, "highguid.lib")

#pragma message("hello")

void exercise28()
{
	char* szWinName[] = {"original",  "polar"};
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	int i = 0, j = 0;
	double color = 255.0;
	int nWidth = 640, nHeight = 480;
	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_8U, 3);
			for (j = 4; j < 8; j ++ )
			{
				cvRectangle(pImage[i], cvPoint(nWidth/j, nHeight/j), cvPoint(nWidth*(j-1)/j, nHeight*(j-1)/j), cvScalar(0, 0, 255), 4);
			}
		
			break;
		default:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, pImage[0]->nChannels);
			cvLogPolar(pImage[0], pImage[i], cvPoint2D32f(pImage[0]->width/2.0, pImage[0]->height/2.0), 50.0);
			break;
		}
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}

}

void exercise29()
{
	char* szWinName[] = {"original", "red", "green", "blue", "realpart Red", "realpart Green", 
		"realpart Blue", "DCT red", "DCT green", "DCT blue", "DCT inverse red",  "DCT inverse green", "DCT inverse blue", 
	"DFT red", "DFT green", "DFT blue", "DFT inverse red", "DFT inverse green", "DFT inverse blue", };
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	int i = 0, j = 0;
	int nWidth = 0, nHeight = 0;
	CvMat myMat;

	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvLoadImage("mytest.jpg");	

			pImage[1] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);			
		
			pImage[2] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);			
	
			pImage[3] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);				
			cvSplit(pImage[0], pImage[3], pImage[2], pImage[1], NULL);
			nWidth = cvGetOptimalDFTSize(pImage[0]->width);
			nHeight = cvGetOptimalDFTSize(pImage[0]->height);
			break;
		case 4: 
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);			
			cvZero(pImage[i]);
			cvConvertScale(pImage[1], pImage[i], 1.0/255);
			break;
		case 5:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[2], pImage[i], 1.0/255.0);
			break;
		case 6:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvConvertScale(pImage[3], pImage[i], 1.0/255.0);
			break;
		case 7:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);				
			cvDCT(pImage[4], pImage[i], CV_DXT_FORWARD);		
			break;
		case 8:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[5], pImage[i], CV_DXT_FORWARD);	
			break;
		case 9:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[6], pImage[i], CV_DXT_FORWARD);	
			break;
	
		case 10:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[7], pImage[i],CV_DXT_INVERSE);
			break;
		case 11:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[8], pImage[i], CV_DXT_INVERSE);
			break;
		case 12:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvDCT(pImage[9], pImage[i], CV_DXT_INVERSE);
			break;
/////////////////////////////////////////////////////////////////////////////////////////		
		case 13:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);
			
			cvZero(pImage[i]);
			cvGetSubRect(pImage[i], &myMat, cvRect(0, 0, pImage[0]->width, pImage[0]->height));
			cvCopy(pImage[4], &myMat);
			cvDFT(pImage[i], pImage[i], CV_DXT_FORWARD, pImage[0]->height);		
			break;
		case 14:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvGetSubRect(pImage[i], &myMat, cvRect(0, 0, pImage[0]->width, pImage[0]->height));
			cvCopy(pImage[5], &myMat);
			cvDFT(pImage[i], pImage[i], CV_DXT_FORWARD, pImage[0]->height);		
			break;
		case 15:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);
			cvZero(pImage[i]);
			cvGetSubRect(pImage[i], &myMat, cvRect(0, 0, pImage[0]->width, pImage[0]->height));
			cvCopy(pImage[4], &myMat);
			cvDFT(pImage[i], pImage[i], CV_DXT_FORWARD, pImage[0]->height);		
			break;			
		case 16:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);			
			cvZero(pImage[i]);			
			cvDFT(pImage[13], pImage[i], CV_DXT_INV_SCALE, pImage[0]->height);
			break;
		case 17:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);			
			cvZero(pImage[i]);
			cvDFT(pImage[14], pImage[i], CV_DXT_INV_SCALE, pImage[0]->height);
			break;
		case 18:
			pImage[i] = cvCreateImage(cvSize(nWidth, nHeight), IPL_DEPTH_64F, 1);			
			cvZero(pImage[i]);
			cvDFT(pImage[15], pImage[i], CV_DXT_INV_SCALE, pImage[0]->height);
			break;
			
		}		
	
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}
}

void exercise30()
{
	char* szWinName[] = {"original", "CANNY", "distance"};
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	int i = 0, j = 0;
	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvLoadImage("mytest.jpg", CV_LOAD_IMAGE_GRAYSCALE);	
			break;
		case 1:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), pImage[0]->depth, 1);
			cvZero(pImage[i]);
			cvCanny(pImage[0], pImage[i], 0, 255);
			break;
		default:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_32F, 1);
			cvZero(pImage[i]);
			cvDistTransform(pImage[1], pImage[i]);
			break;
		}
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}
}


void exercise31()
{
	char* szWinName[] = {"src img", "real src img", "kernel", "real kernel img", "dst img"};
	IplImage* pImage[sizeof(szWinName)/sizeof(char*)] = { NULL };
	int nNumber = sizeof(szWinName)/sizeof(char*);
	int i = 0, nSize = 0;
	CvMat myMat, kernel;
	for (i = 0; i < nNumber; i ++)
	{
		switch (i)
		{
		case 0:
			pImage[i] = cvLoadImage("mysrc.jpg", CV_LOAD_IMAGE_GRAYSCALE);	
			pImage[i+1] = cvCreateImage(cvGetSize(pImage[i]), IPL_DEPTH_32F, 1);
			cvConvertScale(pImage[i], pImage[i+1], 1.0/255.0);
			break;
		case 2:
			pImage[i] = cvLoadImage("mykernel.jpg", CV_LOAD_IMAGE_GRAYSCALE);
			nSize = pImage[i]->width;
			if (pImage[i]->width > pImage[i]->height)
			{
				nSize = pImage[i]->height;
			}
			pImage[i+1] = cvCreateImage(cvSize(nSize, nSize), IPL_DEPTH_32F, 1);
			cvGetSubRect(pImage[i], &myMat, cvRect(0,0, nSize, nSize));			

			cvConvertScale(&myMat, pImage[i+1], 1.0/(1*255.0), -0.319);
			cvGetSubRect(pImage[i+1], &kernel, cvRect(0, 0, nSize, nSize));
			break;
		case 4:
			pImage[i] = cvCreateImage(cvGetSize(pImage[0]), IPL_DEPTH_32F, 1);
			if (nSize % 2 == 0)
			{
				cvFilter2D(pImage[1], pImage[i], &kernel, cvPoint(nSize/2, nSize/2));
			}
			else
			{
				cvFilter2D(pImage[1], pImage[i], &kernel);
			}

			break;
		}
		cvNamedWindow(szWinName[i]);
		cvShowImage(szWinName[i], pImage[i]);
	}
	
	cvWaitKey(0);
	for (i = 0; i < nNumber; i ++)
	{
		cvDestroyWindow(szWinName[i]);
		cvReleaseImage(&pImage[i]);
	}
}

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{	
	exercise31();
	return 0;
}