[計算機軟件及應用]LearningOpenCV課后答案

《[計算機軟件及應用]LearningOpenCV課后答案》由會員分享，可在線閱讀，更多相關(guān)《[計算機軟件及應用]LearningOpenCV課后答案（53頁珍藏版）》請在裝配圖網(wǎng)上搜索。

1、 The Learning of OpenCV Here contains just the exercises in book "Learning OpenCV" and of course I believe there is better solution for them. problems: 1. If you set cvSetImageCOI, dont forget to set it back with parameter "0", otherwise you may end up with single channel.

2、2. If you get your IplImage from "cvCapture", then do NOT release it as it is not created by you! 3. There is some memory allocation in "cvSubImageHeader, and do NOT forget to release them. 4. I tried to erase my drawing lines by "xor" it again, but it seems not working by using "cvGetRow". Maybe

3、 it is because I mess up with "cvSetImageROI without reset it. So, I just use cvCopy to overwrite it. 5. When you draw your rectangle of some width of line, be careful that the rectangle is bigger than that width of line. 6. The color sequence in bytes order is "BGR". The following are exercis

4、es in chapter 4. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// #include #include #include #include #include #include #include

5、 #include #pragma comment(lib, "cvd.lib") #pragma comment(lib, "cxcored.lib") #pragma comment(lib, "highguid.lib") CvFont myfont = cvFont(1, 2); char* szCombineName = "combine image"; bool bMouseButtonDown = false; int x = 0, y = 0; void doDrawing(IplImage* pImage) { c

6、har buffer[256]; int winX = 0, winY = 0; if (bMouseButtonDown) { winX = x; winY = y; sprintf(buffer, "mouse click at [%d,%d]", x, y); cvPutText(pImage, buffer, cvPoint(winX, winY), &myfont, cvScalar(255,0,0)); } } void myMouseCallback(int event, int myx, int myy, int flag, vo

7、id* pUser) { switch (event) { case CV_EVENT_LBUTTONDOWN: bMouseButtonDown = true; x = myx; y = myy; break; case CV_EVENT_LBUTTONUP: bMouseButtonDown = false; break; } } void exercise1() { char* szVideoName = "e:\\mytest.avi"; char* szWindowName = "my video";

8、char* szGrayName = "gray image"; char* szCannyName = "canny image"; CvCapture* pCapture = NULL; IplImage* pImage = NULL; IplImage* pGrayImg = NULL; IplImage* pCannyImg = NULL; IplImage* pCombineImg = NULL; IplImage* pSub1= NULL; IplImage* pSub2= NULL; IplImage* pSub3= NULL; int

9、 nWidth = 0, nHeight = 0; cvNamedWindow(szWindowName); cvNamedWindow(szGrayName); cvNamedWindow(szCannyName); cvNamedWindow(szCombineName); pCapture = cvCreateFileCapture(szVideoName); if (pCapture) { nWidth = (int) cvGetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_WIDTH);

10、 nHeight = (int) cvGetCaptureProperty(pCapture, CV_CAP_PROP_FRAME_HEIGHT); pGrayImg = cvCreateImage(cvSize(nWidth, nHeight), 8, 1); pCannyImg = cvCreateImage(cvSize(nWidth, nHeight), 8, 1); pCombineImg = cvCreateImage(cvSize(nWidth, 3*nHeight), 8, 1); pSub1 = cvCreateImageHeader(cvSize

11、(nWidth, nHeight), 8, 1); pSub2 = cvCreateImageHeader(cvSize(nWidth, nHeight), 8, 1); pSub3 = cvCreateImageHeader(cvSize(nWidth, nHeight), 8, 1); pSub1->origin = pCombineImg->origin; pSub2->origin = pCombineImg->origin; pSub3->origin = pCombineImg->origin; pSub1->widthStep =

12、pCombineImg->widthStep; pSub2->widthStep = pCombineImg->widthStep; pSub3->widthStep = pCombineImg->widthStep; pSub1->imageData = pCombineImg->imageData; pSub2->imageData = pCombineImg->imageData + nHeight*pCombineImg->widthStep; pSub3->imageData = pCombineImg->imageData + nHeigh

13、t*2*pCombineImg->widthStep; cvSetMouseCallback(szCombineName, myMouseCallback, pCombineImg); //cvResizeWindow(szCombineName, pCombineImg->width, pCombineImg->height); do { if (cvWaitKey(15) == 27) { break; } pImage = cvQueryFrame(pCapture); if (pImage)

14、 { cvConvertImage(pImage, pGrayImg, 0); cvCanny(pGrayImg, pCannyImg, 1, 2, 5); //cvShowImage(szWindowName, pImage); //cvShowImage(szGrayName, pGrayImg); //cvShowImage(szCannyName, pCannyImg); cvSetImageCOI(pImage, 1); cvCopy(pImage, pSub1, NULL); cvCop

15、y(pGrayImg, pSub2, NULL); cvCopy(pCannyImg, pSub3, NULL); cvPutText(pSub1, szWindowName, cvPoint(nWidth/2, nHeight/2), &myfont, cvScalar(255,0,0)); cvPutText(pSub2, szGrayName, cvPoint(nWidth/2, nHeight/2), &myfont, cvScalar(255,0,0)); cvPutText(pSub3, szCannyName, cvPoint(

16、nWidth/2, nHeight/2), &myfont, cvScalar(255,0,0)); doDrawing(pCombineImg); cvShowImage(szCombineName, pCombineImg); cvSetImageCOI(pImage, 0); } } while (true); // do NOT release pImage because it is only retrieved from capture //cvReleaseImage(&pImage); cvRele

17、aseImageHeader(&pSub1); cvReleaseImageHeader(&pSub2); cvReleaseImageHeader(&pSub3); cvReleaseImage(&pGrayImg); cvReleaseImage(&pCannyImg); cvReleaseImage(&pCombineImg); cvReleaseCapture(&pCapture); } cvDestroyAllWindows(); } void myMouseOnClick(int event, int x, int y, in

18、t flag, void* pUser) { char buffer[256]; CvFont myFont = cvFont(2, 2); IplImage* pImage = (IplImage*)pUser; char* ptr = NULL; unsigned char r=0, g=0, b=0; switch (event) { case CV_EVENT_LBUTTONDOWN: ptr = pImage->imageData + y*pImage->widthStep + x * pImage->depth* pImage->nCha

19、nnels/8; r = ptr[0]; g = ptr[1]; b = ptr[2]; sprintf(buffer, "rgb [%d,%d,%d]", r,g,b); cvPutText(pImage, buffer, cvPoint(x, y), &myFont, cvScalar(255,0,0)); break; } } void exercise2() { IplImage* pImage = NULL; //, *pCloneImage = NULL; pImage = cvLoadImage("mytest.j

20、pg"); //pCloneImage = cvCloneImage(pImage); cvNamedWindow("mytest"); cvSetMouseCallback("mytest", myMouseOnClick, pImage); do { cvShowImage("mytest", pImage); if (cvWaitKey(1000)==27) { break; } } while (true); cvReleaseImage(&pImage); cvDestroyWindow("mytest");

21、} #define HistogramWidth 48 #define HistogramHeight 800 IplImage* pImage = NULL, *pCloneImage = NULL, *pHistImage= NULL; CvRect rect = cvRect(0,0,0,0); bool bStart = false; #if 0 void eraseFrame() { CvMat vecSrc, vecDst; cvSetImageROI(pImage, rect); cvSetImageROI(pCloneImage

22、, rect); cvGetRow(pImage, &vecSrc, 0); cvGetRow(pCloneImage, &vecDst, 0); cvCopy(&vecSrc, &vecDst); cvGetRow(pImage, &vecSrc, rect.height-1); cvGetRow(pCloneImage, &vecDst, rect.height-1); cvCopy(&vecSrc, &vecDst); cvGetCol(pImage, &vecSrc, 0); cvGetCol(pCloneImage, &vecDst

23、, 0); cvCopy(&vecSrc, &vecDst); cvGetCol(pImage, &vecSrc, rect.width-1); cvGetCol(pCloneImage, &vecDst, rect.width-1); cvCopy(&vecSrc, &vecDst); cvResetImageROI(pImage); cvResetImageROI(pCloneImage); } #else void eraseFrame() { cvSetImageROI(pImage, rect); cvSetImageROI(p

24、CloneImage, rect); cvCopy(pCloneImage, pImage); cvResetImageROI(pImage); cvResetImageROI(pCloneImage); } #endif #define LINE_WIDTH 1 void drawFrame() { cvRectangle(pImage, cvPoint(rect.x, rect.y), cvPoint(rect.x+rect.width-1, rect.y+rect.height-1), cvScalarAll(255), LINE_WIDTH);

25、 //cvLine(pImage, cvPoint(rect.x, rect.y), cvPoint(rect.x+rect.width, rect.y+rect.height), cvScalarAll(255), LINE_WIDTH); } void drawHistogram() { char* ptr = NULL, *pRow = NULL, *pCol = NULL; char buffer[32]; int hist[3][8]= {0}; int index = 0; int nPixWidth = 0; int r, c, i, nOf

26、fset = 0; int x = 0 , y = 0; CvFont myFont = cvFont(1,1); int nMax = 0, nScale=1; nPixWidth = pCloneImage->nChannels*pCloneImage->depth/8; ptr = pCloneImage->imageData + rect.y*pCloneImage->widthStep + rect.x*nPixWidth; pRow = ptr; for (r = 0; r < rect.height; r ++) { pCol = pR

27、ow; for (c = 0; c < rect.width; c ++) { for (i =0; i < 3; i ++) { index = pCol[i] / 32; hist[i][index] ++; if (hist[i][index] > nMax) { nMax = hist[i][index]; } } pCol += nPixWidth; } pRow += pCloneImage->widthStep; } cvSet(pHistImage, c

28、vScalarAll(255)); y = HistogramHeight; nScale = HistogramHeight / HistogramHeight; if (nScale == 0) { nScale = 1; } for (c = 0; c < 8; c ++) { for (i = 0; i < 3; i ++) { unsigned char color[3]={0}; x = nOffset; color[i] = 255; if (hist[i][c] / nScal

29、e != 0) { cvSetImageROI(pHistImage, cvRect(x+i*HistogramWidth, y - hist[i][c]/nScale, HistogramWidth, hist[i][c]/nScale)); cvSet(pHistImage, cvScalar(color[0], color[1], color[2])); cvResetImageROI(pHistImage); } sprintf(buffer, "%d", hist[i][c]); cvPutText(pHistIma

30、ge, buffer, cvPoint(x+i*HistogramWidth, y-100), &myFont, cvScalarAll(0)); } nOffset += HistogramWidth*3; } cvShowImage("histogram", pHistImage); } void myMouseCallback3(int event, int x, int y, int flag, void* pUser) { int w = 0, h = 0; switch (event) { case CV_EVENT_MOUSEMO

31、VE: if (!bStart) { break; } w = x - rect.x; h = y - rect.y; if (w > LINE_WIDTH && h > LINE_WIDTH) { if (w != rect.width || h != rect.height) { if (rect.width > 0 && rect.height > 0) { eraseFrame(); /////////////////////////////////

32、 } rect.width = w; rect.height = h; //cvSetImageROI(pImage, rect); //cvSetImageROI(pCloneImage, rect); //cvSet(pImage, cvScalarAll(255)); drawFrame(); //cvResetImageROI(pImage); //cvResetImageROI(pCloneImage); } } break; case CV_

33、EVENT_LBUTTONDOWN: if (rect.width > 0 && rect.height > 0) { cvSetImageROI(pImage, rect); cvSetImageROI(pCloneImage, rect); cvCopy(pCloneImage, pImage); cvResetImageROI(pImage); cvResetImageROI(pCloneImage); ///////////////////////////////// } rect.x = x;

34、rect.y = y; rect.width = rect.height = 0; bStart = true; break; case CV_EVENT_LBUTTONUP: if (rect.width > 0 && rect.height > 0) { cvSetImageROI(pImage, rect); cvSet(pImage, cvScalarAll(255)); cvResetImageROI(pImage); drawHistogram(); ///////////////////

35、////////////// } bStart = false; break; } } void exercise3() { pImage = cvLoadImage("mytest.jpg"); pCloneImage = cvCloneImage(pImage); cvNamedWindow("histogram"); cvNamedWindow("mytest"); cvSetMouseCallback("mytest", myMouseCallback3, NULL); pHistImage = cvCreateIma

36、ge(cvSize(8 * HistogramWidth * 3, HistogramHeight+200), 8, 3); do { cvShowImage("mytest", pImage); if (cvWaitKey(100)==27) { break; } } while (true); cvReleaseImage(&pImage); cvReleaseImage(&pCloneImage); cvDestroyWindow("mytest"); } int APIENTRY WinMain(HINSTANCE

37、 hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) { exercise3(); //myTest(); return 0; } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// There is a problem that I dont know how to c

38、ontrol the program flow. For example, I setup two cvWaitKey because I place one in my main program and another one in the while loop of "playing video". You see, if you dont place a "cvWaitKey" inside the video playing loop, then there is simply no redrawing of window. Just image there is no ove

39、rlapping threads to either decode video or draw window. The following is a simple program acting as an video player(exercise4) 　 #include #include #include #include #include #include #include #include #pragm

40、a comment(lib, "cvd.lib") #pragma comment(lib, "cxcored.lib") #pragma comment(lib, "highguid.lib") int g_nProgress = 0; int g_nPause = 0; int g_nWait = 0; CvCapture* pCapture = NULL; int nValue = -1; char* szWindowName = "myplayer"; void switchCallback4(int nPos) { double fPos = 0.0;

41、 fPos = (double)nPos / (double)10; if (pCapture) { cvSetCaptureProperty(pCapture, CV_CAP_PROP_POS_AVI_RATIO, fPos); } } void myPlayer() { IplImage* pImage = NULL; do { if (g_nPause == 0) { break; } pImage = cvQueryFrame(pCapture); if (pImage) { cvSho

42、wImage(szWindowName, pImage); } nValue = cvWaitKey(50); } while (nValue == -1); } void switchCallback5(int nPos) { if (nPos == 1) { myPlayer(); } } void exercise4() { pCapture = cvCreateFileCapture("mytest.avi"); if (pCapture) { cvNamedWindow(szWindowName);

43、 cvCreateTrackbar("progress", szWindowName, &g_nProgress, 10, switchCallback4); cvCreateTrackbar("pause", szWindowName, &g_nPause, 1, switchCallback5); do { if (cvWaitKey(0) == 27) { break; } } while(true); cvReleaseCapture(&pCapture); cvDestroyWindow(szW

44、indowName); } } int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) { exercise4(); return 0; } chapter 5 exercises: #include #include #include #include #include #include #incl

45、ude #include #pragma comment(lib, "cvd.lib") #pragma comment(lib, "cxcored.lib") #pragma comment(lib, "highguid.lib") void exercise1() { char* szWindowName[] = {"loadImage", "simpleImage", "simpleNoScale", "NoMedian", "Guassian", "bilateral"}; IplImage* pImage = NULL

46、, *pSimpleImg = NULL, *pNoScaleImg = NULL, *pMedianImg = NULL, *pGaussianImg = NULL, *pBilateralImg = NULL; int i = 0; for (i = 0; i < sizeof(szWindowName)/sizeof(char*); i ++) { cvNamedWindow(szWindowName[i]); } pImage = cvLoadImage("mytest.jpg"); if (pImage) { pSimpleImg =

47、 cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); pNoScaleImg = cvCreateImage(cvSize(pImage->width, pImage->height), IPL_DEPTH_16S, pImage->nChannels); pMedianImg = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels);

48、 pGaussianImg = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); pBilateralImg = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); cvSmooth(pImage, pSimpleImg, CV_BLUR, 5,5, 5,5); cvSmooth(pImage, pNoScaleImg,

49、CV_BLUR_NO_SCALE,11,11, 32,0.5); cvSmooth(pImage, pMedianImg, CV_MEDIAN,5,5, 5,5); cvSmooth(pImage, pGaussianImg, CV_GAUSSIAN,5,5, 5,5); cvSmooth(pImage, pBilateralImg, CV_BILATERAL, 3,3,0.01, 0.003); cvShowImage(szWindowName[0], pImage); cvShowImage(szWindowName[1], pSimpleImg);

50、 cvShowImage(szWindowName[2], pNoScaleImg); cvShowImage(szWindowName[3], pMedianImg); cvShowImage(szWindowName[4], pGaussianImg); cvShowImage(szWindowName[5], pBilateralImg); cvWaitKey(0); cvReleaseImage(&pImage); cvReleaseImage(&pSimpleImg); cvReleaseImage(&pNoScaleImg);

51、 cvReleaseImage(&pMedianImg); cvReleaseImage(&pGaussianImg); cvReleaseImage(&pBilateralImg); } cvDestroyAllWindows(); } void exercise2() { char* szWindowName[] = {"original", "3x3", "5x5", "5x5 second", "9x9", "11x11"}; IplImage* pImage = NULL, *pImage3 = NULL, *pImage5 = NULL,

52、*pImage5_2 = NULL, *pImage7 = NULL, *pImage9 = NULL, *pImage11 = NULL; int i = 0; for (i = 0; i < sizeof(szWindowName)/sizeof(char*); i ++) { cvNamedWindow(szWindowName[i]); } pImage = cvLoadImage("mytest.jpg"); if (pImage) { pImage3 = cvCreateImage(cvSize(pImage->width, pIm

53、age->height), pImage->depth, pImage->nChannels); pImage5 = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); pImage5_2 = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); pImage7 = cvCreateImage(cvSize(pImage->width

54、, pImage->height), pImage->depth, pImage->nChannels); pImage9 = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); pImage11 = cvCreateImage(cvSize(pImage->width, pImage->height), pImage->depth, pImage->nChannels); cvSmooth(pImage, pImage3, CV_GAUSSIAN,

55、 3,3); cvSmooth(pImage, pImage5, CV_GAUSSIAN, 5,5); cvSmooth(pImage5, pImage5_2, CV_GAUSSIAN, 5,5); cvSmooth(pImage, pImage7, CV_GAUSSIAN,7,7); cvSmooth(pImage, pImage9, CV_GAUSSIAN,9,9); cvSmooth(pImage, pImage11, CV_GAUSSIAN,11,11); cvShowImage(szWindowName[0], pImage); cv

56、ShowImage(szWindowName[1], pImage3); cvShowImage(szWindowName[2], pImage5); cvShowImage(szWindowName[3], pImage5_2); cvShowImage(szWindowName[4], pImage7); cvShowImage(szWindowName[5], pImage9); cvShowImage(szWindowName[6], pImage11); cvWaitKey(0); cvReleaseImage(&pImage);

57、cvReleaseImage(&pImage3); cvReleaseImage(&pImage5); cvReleaseImage(&pImage5_2); cvReleaseImage(&pImage7); cvReleaseImage(&pImage9); cvReleaseImage(&pImage11); } cvDestroyAllWindows(); } void exercise3() { IplImage* pImage = NULL, *pImage5 = NULL, *pImage9 = NULL, *pImage5

58、_second = NULL; char* ptr = NULL; int i = 0; char* szWindowName[] = {"original", "5x5", "9x9", "5x5 second"}; pImage = cvCreateImage(cvSize(100, 100), 8, 1); pImage5 = cvCreateImage(cvSize(100, 100), 8, 1); pImage5_second = cvCreateImage(cvSize(100, 100), 8, 1); pImage9 = cvCreateIma

59、ge(cvSize(100, 100), 8, 1); cvSetZero(pImage); cvSetZero(pImage5); cvSetZero(pImage9); ptr = pImage->imageData + pImage->widthStep * 49 + 50 * pImage->depth * pImage->nChannels/8; *ptr = 255; for (i = 0; i < sizeof(szWindowName)/sizeof(char*); i ++) { cvNamedWindow(szWindowNam

60、e[i]); } cvSmooth(pImage, pImage5, CV_GAUSSIAN, 5,5); cvSmooth(pImage5, pImage5_second, CV_GAUSSIAN, 5,5); cvSmooth(pImage, pImage9, CV_GAUSSIAN, 9,9); //cvSmooth(pImage, pImage5); //cvSmooth(pImage, pImage9); //cvSmooth(pImage5, pImage5_second); cvMoveWindow(szWindowName[1], 1

61、00, 200); cvShowImage(szWindowName[0], pImage); cvShowImage(szWindowName[1], pImage5); cvShowImage(szWindowName[2], pImage9); cvShowImage(szWindowName[3], pImage5_second); cvWaitKey(0); cvReleaseImage(&pImage); cvReleaseImage(&pImage5); cvReleaseImage(&pImage9); cvReleaseImage(

62、&pImage5_second); cvDestroyAllWindows(); } void exercise4() { IplImage* pImage[8]= {NULL}; int i = 0; double fSize[3] = {1,4,6}; char* szWindowName[] = {"original", "9-9-x", "0-0-x", "0-0-1-9", "0-0-9-1", "0-0-==>1-9==>9-1", "0-0-9-9","9-9-0-0"}; for (i = 0; i < sizeof(sz

63、WindowName)/sizeof(char*); i ++) { if (i == 0) { pImage[0] = cvLoadImage("mytest.jpg"); } else { pImage[i] = cvCreateImage(cvSize(pImage[0]->width, pImage[0]->height), pImage[0]->depth, pImage[0]->nChannels); } cvNamedWindow(szWindowName[i]); } for (i = 0; i <

64、3; i ++) { cvSmooth(pImage[0], pImage[1], CV_GAUSSIAN, 9,9,fSize[i]); cvSmooth(pImage[0], pImage[2], CV_GAUSSIAN, 0,0,fSize[i]); cvShowImage(szWindowName[0], pImage[0]); cvShowImage(szWindowName[1], pImage[1]); cvShowImage(szWindowName[2], pImage[2]); cvWaitKey(0); } // c.

65、 cvSmooth(pImage[0], pImage[3], CV_GAUSSIAN, 0,0,1,9); cvShowImage(szWindowName[3], pImage[3]); // d. cvSmooth(pImage[0], pImage[4], CV_GAUSSIAN, 0,0,9,1); cvShowImage(szWindowName[4], pImage[4]); // e cvSmooth(pImage[3], pImage[5], CV_GAUSSIAN, 0,0,9,1); cvShowImage(szWindowName[

66、5], pImage[5]); // f. cvSmooth(pImage[3], pImage[6], CV_GAUSSIAN, 0,0,9,9); cvShowImage(szWindowName[6], pImage[6]); cvSmooth(pImage[3], pImage[7], CV_GAUSSIAN, 9,9,0,0); cvShowImage(szWindowName[7], pImage[7]); cvShowImage(szWindowName[0], pImage[0]); ////////////////////////////////////////////////// cvWaitKey(0); for (i = 0; i < sizeof(szWindowName)/sizeof(char*); i ++) { cvReleaseImage(&pImage[i]); } cvDestroyAllWindows(); } int APIENTRY Wi