《学习opencv》第三章课后习题详解

第一题：

 

3_1:
// chapter_3.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "stdio.h"
#include "cxcore.h" //处理数据结构
#include "cv.h"
#include "types_c.h"


int _tmain(int argc, _TCHAR* argv[])
{
	printf("a***选取一个负的浮点数，取他的绝对值，四舍五入后，取它的极值***\n");
	double fudian = -123.4532;
	printf("\t默认选取的负数为：%f\n", fudian);
	double fudian1 = fabs(fudian);
	printf("\t其绝对值为：%f\n", fudian1);
	int fudian3 = cvRound(fudian1);
	printf("\t四舍五入之后,极值为：%d\n", fudian3);
	printf("b***产生一些随机数***\n");
	CvRNG rng = cvRNG(cvGetTickCount());
	printf("\t");
	for (int i = 0; i < 10; i++)
	{
		printf("*%d", cvRandInt(&rng) % 256);
	}
	printf("\n");
	printf("c***Cvpoint2D32f类型到CvPoint类型的转换***\n");
	CvPoint2D32f cpf = cvPoint2D32f(89.2345, 78.6745);
	printf("\t该cvpoint2d32f数为%f,%f\n", cpf.x, cpf.y);
	CvPoint cpf1 = cvPointFrom32f(cpf);
	printf("\t转换后的cvpoint数为%d,%d\n", cpf1.x, cpf1.y);
	printf("c***Cvpoint类型到CvPoint2D32f类型的转换***\n");
	CvPoint cv = cvPoint(678, 789);
	CvPoint2D32f cv1 = cvPointTo32f(cv);
	printf("\t原来的cvpoint数：%d,%d\n", cv.x, cv.y);
	printf("\t现在的cvpoint2d32f数：%f,%f\n", cv1.x, cv1.y);
	system("pause");
	return 0;
}

 

函数解析：

 

 

fabs() //取绝对值
cvRound() //对double型数据四舍五入后返回int型数据
cvGetTickCount() //返回64位长整数的时间数据,为CvRNG设置的专用种子。
cvRNG() //函数 cvRNG 初始化随机数生成器并返回其状态。指向这个状态的指针可以传递给函数 cvRandInt, cvRandReal 和 cvRandArr 
cvRandInt() //返回均匀分布的随机 32-bit 无符号整型值并更新 RNG 状态。
cvPointFrom32f() /*cvPoint转CvPoint2D32f
CV_INLINE  CvPoint  cvPointFrom32f( CvPoint2D32f point )
{
    CvPoint ipt;
    ipt.x = cvRound(point.x);
    ipt.y = cvRound(point.y);

    return ipt;
}
*/

cvPointTo32f() /*CvPoint2D32f转cvPoint
CV_INLINE  CvPoint2D32f  cvPointTo32f( CvPoint point )
{
    return cvPoint2D32f( (float)point.x, (float)point.y );
}
*/

 

 

 

第二题：

 

#include"cv.h"
#include"stdafx.h"
#include"highgui.h"

int _tmain(int argc, _TCHAR* argv[])
{
	CvMat* srcMat = cvCreateMat(100, 100, CV_8UC3);
	cvSetZero(srcMat);
	CvPoint cirPoint = cvPoint(50, 50);
	int r = 40;
	CvScalar circolor = cvScalar(25, 100,50);
	cvCircle(srcMat, cirPoint, r,circolor);
	cvNamedWindow("circle");
	cvShowImage("circle", (CvArr*)srcMat);
	cvWaitKey(0);
	cvReleaseMat(&srcMat);
	cvDestroyWindow("circle");
	return 0;
}

 

函数解析：

 

 

cvCreateMat( int rows, int cols, int type ); //创建一个矩阵，长*高（像素），以及类型CV_8UC3为8位无符号三通道
cvSetZero(srcMat); //清零矩阵
cvCircle( CvArr* img, CvPoint center, int radius,CvScalar color, int thickness CV_DEFAULT(1),
     int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0));
/*画圆
载体矩阵，圆心坐标（像素），半径（像素），圆周颜色，半径粗细，圆周线的类型（见），圆心坐标点和半径值的小数点位数
*/

 

 

 

第三、四题：

 

#include"stdafx.h"
#include"cv.h"
#include"highgui.h"

int _tmain(int argc, _TCHAR* argv[])
{
	CvMat* mat = cvCreateMat(100, 100, CV_8UC3);
	cvSetZero(mat);
	//矩形平面
	for (int row = 20; row < 40; row++)
		for (int col = 5; col < 20; col++)
		{
			uchar* ptr = cvPtr2D((CvArr*)mat, row, col);
			ptr[1] = 255;
		}
	/*3_3为矩形，代替for循环里的内容
	uchar* ptr;
	for (int row = 20; row <= 40; row++)
		for (int col = 5; col <= 20; col++)
		{
			if (row == 20 || row == 40)
			{
				ptr = cvPtr2D((CvArr*)mat, row, col);
				ptr[1] = 255;
			}
			else
			{
				ptr = cvPtr2D((CvArr*)mat, row, 5);
				ptr[1] = 255;
				ptr = cvPtr2D((CvArr*)mat, row, 20);
				ptr[1] = 255;
			}
		}
	*/
	cvNamedWindow("green rectangle");
	cvShowImage("green rectangle", (CvArr*)mat);
	cvWaitKey(0);
	cvReleaseMat(&mat);
	cvDestroyWindow("green rectangle");
	return 0;
}

 

函数解析：

 

 

cvPtr2D( const CvArr* arr, int idx0, int idx1, int* type CV_DEFAULT(NULL) );
/*
返回一个uchar型的指向矩阵中元素的指针，idx0，idx1为索引的值，最后一个为可选参数，表示输出值的类型
*/

 

第五题：

 

#include"stdafx.h"
#include"cv.h"
#include"highgui.h"

int _tmain(int argc, _TCHAR* argv[])
{
	IplImage* img = cvCreateImage(cvSize(210, 210), 8, 1);
	cvZero(img);
	int hength = 210, width = 210, board = 10;
	int value = 0;
	for (int i=0,j=0; i<=200;)
	{
		cvSetImageROI(img, cvRect(i, j, width, hength));
		cvSet(img, cvScalar(value, 0, 0));
		cvResetImageROI(img);
		i += 10;
		j += 10;
		if (value<+255)
			value += 10;
	}
	cvNamedWindow("ROL");
	cvShowImage("ROL", img);
	cvWaitKey(0);
	cvReleaseImage(&img);
	cvDestroyWindow("ROL");
	return 0;
}

 

函数解析：

cvSetImageROI( IplImage* image, CvRect rect );
/*
选择特定的区域，与cvResetImageROI连用，所选取的特定区域在这两个函数之间有效。
两个参数：所要选取的图像以及选取的范围
*/
cvSet(CvArr* arr,CvScalar value);//设置矩阵的值
cvResetImageROI( IplImage* image );//取消选中

 

第六题：

 

#include"stdafx.h"
#include"cv.h"
#include"highgui.h"

int _tmain(int argc, _TCHAR* argv[])
{
	IplImage* img = NULL;//判断一下图像是否加载到
	img = cvLoadImage("board.jpg");
	IplImage* dst1, *dst2;
	dst1 = cvCreateImage(cvSize(20, 30), img->depth, img->nChannels);
	dst2 = cvCreateImage(cvSize(20, 30), img->depth, img->nChannels);
	dst1->origin = img->origin;
	dst1->widthStep = img->widthStep;
	dst2->origin = img->origin;
	dst2->widthStep = img->widthStep;
	dst1->imageData = img->imageData + img->widthStep * 10 + img->nChannels * 5;
	dst2->imageData = img->imageData + img->widthStep * 60 + img->nChannels * 50;
	cvNot(dst1, dst1);
	cvNot(dst2, dst2);

	cvNamedWindow("img");

	cvShowImage("img", img);

	cvWaitKey(0);

	cvReleaseImage(&img);
	cvReleaseImage(&dst1);
	cvReleaseImage(&dst2);

	cvShowImage("img", img);
	cvDestroyWindow("img");
	return 0;
}

 

 

 

函数解析：

 

 

cvNot( const CvArr* src, CvArr* dst ) //将原矩阵里的像素值取反，送到目标矩阵
/*
这里需要注意的是结构IplImage里的几个参数：
origin：选择坐标原点是在左上角还是左下角
widthStep:图像的行大小，以字节为单位，永远是四的倍数，不足的话自动补齐。
如程序中的img图像width = 640，nchannels = 3,一个通道是八位代表一个字节，因此widthstep = 640*3 = 1920个字节
imageData：指向图像数据的指针，默认指向图像的第(1,1)个像素

这里创建的两个图像头img，img2并没有正真的图像数据，他们的imgeData指针指向img的图像数据，因此他们会显示在img图像上。
*/

 

第七题：

 

#include"stdafx.h"
#include"cv.h"
#include"highgui.h"

int _tmain(int argc, _TCHAR* argv[])
{
	IplImage* src = cvLoadImage("board.jpg");
	IplImage* Rimag = cvCreateImage(cvGetSize(src), src->depth, 1);
	IplImage* Gimag = cvCreateImage(cvGetSize(src), src->depth, 1);
	IplImage* Bimag = cvCreateImage(cvGetSize(src), src->depth, 1);
	IplImage* clone1, *clone2;
	double G_MAX_PIX = 0;
	double G_MIN_PIX = 0;
	cvSplit(src, Rimag, Gimag, Bimag,NULL);//分离时的顺序到底是RGB还是BGR还不确定？

	clone1 = cvCloneImage(Gimag);
	clone2 = cvCloneImage(Gimag);

	cvMinMaxLoc(Gimag, &G_MIN_PIX, &G_MAX_PIX);

	double thresh = (unsigned char)(G_MAX_PIX - G_MIN_PIX) / 2.0;
	

	cvSet(clone1, cvScalar(thresh));
	cvSetZero(clone2);
	cvCmp(Gimag, clone1, clone2, CV_CMP_GE);
	cvSubS(Gimag, cvScalar(thresh / 2.0), Gimag, clone2);

	cvNamedWindow("src");
	cvNamedWindow("clone2");

	cvShowImage("src", src);
	cvShowImage("clone2", clone2);

	cvWaitKey(0);

	cvReleaseImage(&src);
	cvReleaseImage(&clone1);
	cvReleaseImage(&Rimag);
	cvReleaseImage(&Gimag);
	cvReleaseImage(&Bimag);
	cvReleaseImage(&clone2);


	cvDestroyWindow("src");
	cvDestroyWindow("clone2");
	return 0;
}

 

 

 

函数解析：

 

 

cvSplit( const CvArr* src, CvArr* dst0, CvArr* dst1,CvArr* dst2, CvArr* dst3 );
/*分离图像，分割多通道数组成几个单通道数组或者从数组中提取一个通道，目标图像只能是单通道*/
cvCloneImage( const IplImage* image ); /*克隆图像，函数自己会单独开一块内存，将复制的图像数据放进去
而cvCopy()则必须先创建一个图像*/
cvMinMaxLoc( const CvArr* arr, double* min_val, double* max_val,CvPoint* min_loc CV_DEFAULT(NULL),
             CvPoint* max_loc CV_DEFAULT(NULL),const CvArr* mask CV_DEFAULT(NULL) );
/*
	获取图像中像素值最大、最小的值以及他们的CPoint位置
*/

cvCmp( const CvArr* src1, const CvArr* src2, CvArr* dst, int cmp_op );
/*
	比较另个图像对应位置的像素值，如果条件为真，则结果矩阵对应位为0xff,否则为零。
	cmp_op有以下几种：
	CV_CMP_EQ (src1i == src2i)
	CV_CMP_GT (src1i > src2i)
	CV_CMP_GE (src1i >= src2i)
	CV_CMP_LT (src1i < src2i)
	CV_CMP_LE (src1i <= src2i)
	CV_CMP_NE (src1i != src2i)
*/
cvSubS( const CvArr* src, CvScalar value, CvArr* dst, const CvArr* mask CV_DEFAULT(NULL))
/*
将原图像每一个像素值减去一个值得到目标图像。
最后一个参数mask为矩阵开关：如果该矩阵非空，则dst将会与mask比较，对应mask中0元素的位置，在dst中不会被改变
*/

 

 

 

第八题：

 

#include"stdafx.h"
#include"cv.h"
#include"highgui.h"
#include"stdio.h"

typedef struct my_struct
{
	int i;
	CvPoint point;
	CvRect rect;
}Mystruct;

void write_my_struct(CvFileStorage* fs,const char* name, Mystruct* ms)
{
	cvStartWriteStruct(fs, name, CV_NODE_MAP);
	cvWriteInt(fs, "my_struct_value", ms->i);

	cvStartWriteStruct(fs, "my_struct_point", CV_NODE_SEQ);



	cvWriteInt(fs, 0, ms->point.x);
	cvWriteInt(fs, 0, ms->point.y);
	cvEndWriteStruct(fs);
	 
	cvStartWriteStruct(fs, "my_struct_rect", CV_NODE_SEQ);
	cvWriteInt(fs, 0, ms->rect.x);
	cvWriteInt(fs, 0, ms->rect.y);
	cvWriteInt(fs, 0, ms->rect.width);
	cvWriteInt(fs, 0, ms->rect.height);
	cvEndWriteStruct(fs);

	cvEndWriteStruct(fs);
}

void read_my_stuct(CvFileStorage* fs, CvFileNode* ms_node, my_struct* ms)
{
	int i = cvGetFileNodeByName(fs, ms_node, "my_struct_value")->data.i;
	ms->i = i;

	CvSeq* s1 = cvGetFileNodeByName(fs, ms_node, "my_struct_point")->data.seq;
	CvPoint point;
	point.x = cvReadInt((CvFileNode*)cvGetSeqElem(s1, 0));
	point.y = cvReadInt((CvFileNode*)cvGetSeqElem(s1, 1));
	ms->point = point;

	CvSeq* s2 = cvGetFileNodeByName(fs, ms_node, "my_struct_rect")->data.seq;
	CvRect rect;
	rect.x = cvReadInt((CvFileNode*)cvGetSeqElem(s2, 0));
	rect.y = cvReadInt((CvFileNode*)cvGetSeqElem(s2, 1));
	rect.width = cvReadInt((CvFileNode*)cvGetSeqElem(s2, 3));
	rect.height = cvReadInt((CvFileNode*)cvGetSeqElem(s2, 2));
	ms->rect = rect;
}

void ShowStructValue(Mystruct* pvalue)
{
	printf("integer:%d\n", pvalue->i);
	printf("CvPoint: (%d, %d)\n", pvalue->point.x, pvalue->point.y);
	printf("CvRect: h-->%d\tw-->%d\t(%d, %d)\n", pvalue->rect.height,pvalue->rect.width, pvalue->rect.x, pvalue->rect.y);
}

int _tmain(int argc, _TCHAR* argv[])
{
	const char* filename = "example.xml";
	char name[12];
	CvFileStorage* fs = cvOpenFileStorage(filename, 0, CV_STORAGE_WRITE);
	for (int i = 0; i < 10; i++)
	{
		CvRNG rng = cvRNG(cvGetTickCount());
		int total = cvRandInt(&rng);
		my_struct ms = { total%256, cvPoint(total%512, total%233), cvRect(total%78, total%128, total%233, total%321)};
		sprintf(name, "mystruct%d", i);
		write_my_struct(fs, name, &ms);
	}
	cvReleaseFileStorage(&fs);
	
	fs = cvOpenFileStorage(filename, 0, CV_STORAGE_READ);
	my_struct ms1;
	for (int i = 0; i < 10; i++)
	{
		sprintf(name, "mystruct%d", i);
		CvFileNode* pnode = cvGetFileNodeByName(fs, NULL, name);
		read_my_stuct(fs, pnode, &ms1);
		ShowStructValue(&ms1);
	}
	cvReleaseFileStorage(&fs);
	system("pause");
	return 0;
}

 

函数解析：

 

 

cvStartWriteStruct()与cvEndWriteStruct()
/*在这两个函数之间写入结构体数据，当需要写入结构体的时候需要嵌套使用这两个函数，非结构体不需要
  这两个函数的使用使写入到文件里的数据层次分明。
  void cvStartWriteStruct(CvFileStorage* fs, const char* name, int struct_flags)
fs:文件存储器
name：为数据结构的名称
struct_flags：
		CV_NODE_SEQ - 被写入的数据结构为序列结构。这样的数据没有名称。
		CV_NODE_MAP - 被写入的数据结构为图表结构。这样的数据含有名称。
		以上两个必须二选一。
		CV_NODE_FLO 这个可选择标识符只能作用于YAML流。被写入的数据结构被看做一个数据流（不是数据块），它更加紧凑，当结构或数组里的数据是标量时，推荐用这个标志。
cvEndWriteStruct( CvFileStorage* fs );
		结束写结构体
*/

void cvWriteInt( CvFileStorage* fs, const char* name, int value );//向指定文件存储器写入整型数据，name为数据结构的名称

CvFileNode* cvGetFileNodeByName( const CvFileStorage* fs,const CvFileNode* map,const char* name );
/*
根据数据结构的名称获取结点，只由获取结点才能读取该结点下的数据。返回该数据的结点
fs:文件存储器
map:文件结点这里指父结点，没有的话为null
name：为数据结构的名称
*/

int cvReadInt( const CvFileNode* node, int default_value CV_DEFAULT(0) )//从结点读取整型数据

CvFileStorage* cvOpenFileStorage( const char* filename, CvMemStorage* memstorage,int flags, const char* encoding CV_DEFAULT(NULL) );
/*打开文件，返回文件存储器
flags:
	#define CV_STORAGE_READ          0
	#define CV_STORAGE_WRITE         1
*/

typedef struct CvFileNode
{
    int tag;
    struct CvTypeInfo* info; /* type information
            (only for user-defined object, for others it is 0) */
    union
    {
        double f; /* scalar floating-point number */
        int i;    /* scalar integer number */
        CvString str; /* text string */
        CvSeq* seq; /* sequence (ordered collection of file nodes) */
        CvFileNodeHash* map; /* map (collection of named file nodes) */
    } data;
}

cvGetSeqElem( const CvSeq* seq, int index );
/*根据所得seq得到seq表示结构体中的每一项数据,返回
char类型的指针，可以利用强制类型转换，转换为序列中实际存储的数据类型
data.i:表示取出整型数据
data.sep:b表示取出结构数据
*/

给出一次存储后文件中结构，方便理解，结构类似于树

<?xml version="1.0"?>
<opencv_storage>
<mystruct0>//最外层的结构名，为CV_NODE_MAP结构型
  <my_struct_value>32</my_struct_value>
  <my_struct_point>32 94</my_struct_point>
  <my_struct_rect>6 32 94 258</my_struct_rect>
</mystruct0>
</opencv_storage>

在画一幅图对应文件中的数据结构加强理解：