C++ cvSetZero函数代码示例

int grow_mat::reserve(int maxrows, int maxcols)
{
	if (_mat==0 || maxrows<0 || maxcols<0)
		return 0;

	// 只要申请的矩阵的行或列大于当前矩阵就分配内存
	if (maxrows > _mat->rows || maxcols > _mat->cols) 
	{
		// 新矩阵
		CvMat * nm = cvCreateMat(maxrows, maxcols, _mat->type);
		if (nm==0)
			return 0;
		if (_zero_flag) cvSetZero(nm);
		if (this->rows && this->cols && _copy_flag)
		{
			// 若当前矩阵大小不为0，且需要复制数据，则将当前矩阵this的数据复制到nm
			CvMat sub;
			cvGetSubRect(nm, &sub, cvRect(0,0,this->cols, this->rows));
			cvCopy(this, &sub);
		}
		cvReleaseMat(&_mat);
		_mat = nm;
	}
	return 1;
}

int grow_mat::init(int r, int c, int type, int maxrows, int maxcols)
{
	int no_max = 0;
	if (maxrows==0) {maxrows=r*_expand_factor;no_max=1;}
	if (maxcols==0) {maxcols=c*_expand_factor;no_max=1;}
	if (type==0) type=CV_64FC1;
	if (r<=0 || c<=0 || maxrows<0 || maxcols<0 || r>maxrows || c>maxcols)
		return 0;

	// 为了和mini_solver的set_solver一致，允许再次初始化！
	if (_mat)
	{
		// 若矩阵_mat存在，且类型相同，表示客户想改变大小。
		int mat_type = CV_MAT_TYPE(_mat->type);
		if (CV_MAT_TYPE(type)==mat_type)
		{
			return resize(r,c);
		}
	}

	if(_mat) cvReleaseMat(&_mat);
	if (no_max)
		_mat = cvCreateMat(r, c, type);
	else
		_mat = cvCreateMat(maxrows, maxcols, type);
	if (_mat==0) return 0;
	if (_zero_flag) cvSetZero(_mat);
	cvGetSubRect(_mat, this, cvRect(0,0,c,r));
	return 1;
}

void ofxOpticalFlowFarneback::reset() {
	colrImgLrg.set(0);
	colrImgSml.set(0);
	greyImgLrg.set(0);
	greyImgSml.set(0);
	greyImgPrv.set(0);
	cvSetZero(flow);
}

void ofxCvOpticalFlowLK::allocate(int _w, int _h){
	width		= _w;
	height		= _h; 
	invWidth	= 1.0f/width;
	invHeight	= 1.0f/height;
	
	if(vel_x) cvReleaseImage(&vel_x);		// MEMO
	if(vel_y) cvReleaseImage(&vel_y);		// MEMO
	
	vel_x = cvCreateImage( cvSize( width, height ), IPL_DEPTH_32F, 1  );
	vel_y = cvCreateImage( cvSize( width, height ), IPL_DEPTH_32F, 1  );
	
    cvSetZero(vel_x);
    cvSetZero(vel_y);
	
	resetROI();
}

void ShowTrackResult(IplImage *ShowTrack, MyTrackStruct TrackT[],int NumOfTrack)
{
	cvSetZero(ShowTrack);

	for (int i = 0; i < NumOfTrack; i++)
	{
		if (TrackT[i].TrackLife == 0)
		{
			continue;
		}

		int LeftTop_y = 12 * i;
		int RightButton_y = LeftTop_y + 10;

		if (RightButton_y >= ShowTrack->height)//防止图片数据访问越界
			break;

		for (int j = 0; j < (TrackT[i].NumOFTrackList + 1); j++)
		{
			int LeftTop_x = 12 * j;
			int RightButton_x = 12 * (j + 1) - 2;

			if (RightButton_x >= ShowTrack->width)//防止图片数据访问越界
				goto SHOW_ShowImage;//内层的跳出用什么好？


			//画矩形块
			for (int h = LeftTop_y; h < RightButton_y + 1; h++)
			{
				for (int w = LeftTop_x; w < RightButton_x + 1; w++)
				{
					int color;
					if (j == 0)
					{
						color = 2;
					}
					if (j == 1)
					{
						color = 0;
					}
					if (j > 1)
					{
						color = 1;
					}

					ShowTrack->imageData[(h * ShowTrack->width + w) * 3 + color] = 255;
				}
			}
		}
	}





SHOW_ShowImage:	
	cvShowImage("TrackBar", ShowTrack);
}

//table查找表，rows查找表行数,cols查找表列数,usecols所使用到的列数，不能大于cols
//pframe的大小为(usecols+1)/2，pframe[0]为主分量，pframe[1]...pframe[(usecols+1)/2]为辅分量
//根据查找表检测猪只
void cvLookUpTable(int *table,const int Rows,const int Cols,const int usecols,IplImage** pframe, IplImage* mask){
	assert(Cols>=usecols);
	const int IMGNUM=(usecols-1)/2;
	IplImage **imgs=new IplImage*[IMGNUM];
	IplImage *grayImg=pframe[0];
	IplImage *img=grayImg;
	for (int i=0; i<IMGNUM; ++i)
	{
		imgs[i] =pframe[i+1];
	}
	cvSetZero(mask);
	int *param=new int[usecols-1];
	int *componPiex=new int[IMGNUM];
	for (int i=0; i<img->height; ++i){
		for (int j=0; j<img->width; ++j){
			uchar grayPiex=((unsigned char *)grayImg->imageData+ i* grayImg->widthStep)[j];
			for (int m=0; m<Rows; ++m)
			{
				if (grayPiex==table[m*Cols+0])
				{
					for (int n=0; n<usecols-1; ++n)
					{
						param[n]=table[m*Cols+n+1];
					}
					for (int imgnumIndex=0; imgnumIndex<IMGNUM; ++imgnumIndex){
						componPiex[imgnumIndex]=((unsigned char *)imgs[imgnumIndex]->imageData+ i* imgs[imgnumIndex]->widthStep)[j];
					}
					bool isObjectPiex=true;
					for (int n=0; n<IMGNUM; ++n)
					{
						if (!(componPiex[n]>param[n*2] && componPiex[n] <param[n*2+1])){
							isObjectPiex=false;
							break;
						}
					}
					if (isObjectPiex==true)
					{
						((unsigned char *)mask->imageData+ i* mask->widthStep)[j]=255;
					}
					break;//for (int m=0; m<Rows; ++m)
				}				
			}
		}
	}
	if (imgs){
		delete[] imgs;
		imgs=NULL;
	}
	if (componPiex){
		delete[] componPiex;
		componPiex=NULL;
	}
	if(param) {
		delete []param;
		param=NULL;
	}
}

bool processFrame(xn::DepthGenerator* dpg,xn::UserGenerator* ug,XnUserID userID)
{
	if (!dImage)
	{
		dImage=cvCreateImage(dSize,IPL_DEPTH_16U,1);
		uImage=cvCreateImage(dSize,IPL_DEPTH_8U,1);
		showImage=cvCreateImage(dSize,IPL_DEPTH_8U,1);
	}
	cvSetZero(dImage);
	cvSetZero(uImage);
	if (!convertMetaDataToIpl( dpg,ug,userID))	//Convert Xn Matrices to OpenCV Matrices for easier calculation.
		return false;
	optimizeDepthMap();
	getSphereSizes(dpg,ug,userID);
	measureBody(dpg,ug,userID);
	estimateParameters();
	return true;
}

IplImage *TBackground::CreateTestImg()
{
  IplImage *pImage = cvCreateImage(cvSize(256, 256), IPL_DEPTH_8U, 3);

  if(pImage != NULL)
    cvSetZero(pImage);

  return pImage;
}

////Improving shadow suppression in moving object detection with HSV color information里阴影检测的算法
//TS，TH分别表示H分量、S分量的阈值，可通过实验来确定。因数阴影点的V分量值通常小于非阴影点相应的V分量值，
//所以β取值应该小于1，而α的取值则需要考虑场景光线的强弱，光线越强，α取值越小
bool ShadowDetect(const IplImage *srcImg,const IplImage *bgImg,const IplImage *mask,
	const double Alpha, const double Beta, const double TS, const double TH,IplImage *dstImg)
{
	if (!srcImg || !bgImg || !dstImg || (mask && mask==dstImg)
		|| srcImg->width != bgImg->width ||  (mask && srcImg->width !=mask->width) || srcImg->width != dstImg->width
		|| srcImg->height!=bgImg->height || (mask && srcImg->height!=mask->height) || srcImg->height!=dstImg->height
		|| srcImg->nChannels!=3 || bgImg->nChannels!=3 || (mask && mask->nChannels!=1) || dstImg->nChannels!=1)
	{
		return false;
	}
	cvSetZero(dstImg);
	IplImage *channelsImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,3);
	IplImage *IhImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	IplImage *IsImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	IplImage *IvImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	IplImage *BhImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	IplImage *BsImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	IplImage *BvImg=cvCreateImage(cvGetSize(srcImg),IPL_DEPTH_8U,1);
	cvCvtColor(srcImg,channelsImg,CV_RGB2HSV);
	cvSplit(channelsImg,IhImg,IsImg,IvImg,NULL);
	cvCvtColor(bgImg,channelsImg,CV_RGB2HSV);
	cvSplit(channelsImg,BhImg,BsImg,BvImg,NULL);
	uchar Ih,Is,Iv,Bh,Bs,Bv;
	for (int i=0; i<srcImg->height; ++i){
		for (int j=0; j<srcImg->width; ++j){
			Ih=((uchar*)IhImg->imageData + i *IhImg->widthStep)[j];
			Is=((uchar*)IsImg->imageData + i *IsImg->widthStep)[j];
			Iv=((uchar*)IvImg->imageData + i *IvImg->widthStep)[j];
			Bh=((uchar*)BhImg->imageData + i *BhImg->widthStep)[j];
			Bs=((uchar*)BsImg->imageData + i *BsImg->widthStep)[j];
			Bv=((uchar*)BvImg->imageData + i *BvImg->widthStep)[j];
			if (mask){
				uchar maskPiex=((uchar*)mask->imageData + i *mask->widthStep)[j];
				if (maskPiex){
					if (Iv*1./Bv>Alpha && Iv*1./Bv<Beta
						&& abs(Is-Bs)<=TS && abs(Ih-Bh)<=TH){
							((uchar*)dstImg->imageData + i *dstImg->widthStep)[j]=255;
					}
				}
			}else{
				if (Iv*1./Bv>Alpha && Iv*1./Bv<Beta
					&& abs(Is-Bs)<=TS && abs(Ih-Bh)<=TH){
						((uchar*)dstImg->imageData + i *dstImg->widthStep)[j]=255;
				}
			}
		}
	}
	cvReleaseImage(&channelsImg);
	cvReleaseImage(&IhImg);
	cvReleaseImage(&IsImg);
	cvReleaseImage(&IvImg);
	cvReleaseImage(&BhImg);
	cvReleaseImage(&BsImg);
	cvReleaseImage(&BvImg);
	return true;
}

IplImage *rotateImage(const IplImage *img, int angle) 
{
    IplImage *newImg;
    int newWidth, newHeight;
    int rectX, rectY;
    if (angle == -45 || angle == 45) {
        newWidth = (int) ((img->width + img->height) / sqrt(2.0));
        newHeight = (int) ((img->width + img->height) / sqrt(2.0));
        
    } else if (angle == -90 || angle == 90) {
        if (img->width > img->height) {
            newWidth = img->width;
            newHeight = img->width;
        } else {
            newWidth = img->height;
            newHeight = img->height;
        }
    } else {
        newWidth = img->width;
        newHeight = img->height;
    }
    
    newImg = cvCreateImage(cvSize(newWidth, newHeight), img->depth,
                           img->nChannels);
    cvSetZero(newImg);
    
    rectX = (int) ((newWidth - img->width) / 2);
    rectY = (int) ((newHeight - img->height) / 2);
    
    CvRect rect = cvRect(rectX, rectY, img->width, img->height);
    
    cvSetImageROI(newImg, rect);
    
    cvResize(img, newImg, CV_INTER_LINEAR);
    cvResetImageROI(newImg);
    
    IplImage *rotatedImg = cvCreateImage(cvGetSize(newImg), IPL_DEPTH_8U,
                                         img -> nChannels);
    
    CvPoint2D32f center;
    int xPos, yPos;
    
    xPos = (int) newWidth / 2;
    yPos = (int) newHeight / 2;
    
    CvMat *mapMatrix = cvCreateMat(2, 3, CV_32FC1);
    
    center.x = xPos;
    center.y = yPos;
    
    cv2DRotationMatrix(center, angle, 1.0, mapMatrix);
    cvWarpAffine(newImg, rotatedImg, mapMatrix, CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS, cvScalarAll(255.f));
    return rotatedImg;
}

IplImage *TBackgroundVuMeter::CreateTestImg()
{
  IplImage *pImage = NULL;

  if(m_nBinCount > 0)
    pImage = cvCreateImage(cvSize(m_nBinCount, 100), IPL_DEPTH_8U, 3);

  if(pImage != NULL)
    cvSetZero(pImage);

  return pImage;
}

CvMat* AbstractCamera::computeKMatrix(double focalLength, float pX, float pY) {

	CvMat* kMatrix = cvCreateMat(3, 3, CV_32FC1);
	cvSetZero(kMatrix);
	cvmSet(kMatrix, 0, 0, focalLength);
	cvmSet(kMatrix, 1, 1, focalLength);
	cvmSet(kMatrix, 0, 2, pX);
	cvmSet(kMatrix, 1, 2, pY);
	cvmSet(kMatrix, 2, 2, 1.0f);

	return kMatrix;
}

/**
- FUNCIÓ: Mean
- FUNCIONALITAT: Get blob mean color in input image
- PARÀMETRES:
	- image: image from gray color are extracted
- RESULTAT:
	- 
- RESTRICCIONS:
	- 
- AUTOR: rborras
- DATA DE CREACIÓ: 2008/05/06
- MODIFICACIÓ: Data. Autor. Descripció.
*/
double CBlob::Mean( IplImage *image )
{
	// it is calculated?
/*	if( m_meanGray != -1 )
	{
		return m_meanGray;
	}
*/	
	// Create a mask with same size as blob bounding box
	IplImage *mask;
	CvScalar mean, std;
	CvPoint offset;

	GetBoundingBox();
	
	if (m_boundingBox.height == 0 ||m_boundingBox.width == 0 || !CV_IS_IMAGE( image ))
	{
		m_meanGray = 0;
		return m_meanGray;
	}

	// apply ROI and mask to input image to compute mean gray and standard deviation
	mask = cvCreateImage( cvSize(m_boundingBox.width, m_boundingBox.height), IPL_DEPTH_8U, 1);
	cvSetZero(mask);

	offset.x = -m_boundingBox.x;
	offset.y = -m_boundingBox.y;

	// draw contours on mask
	cvDrawContours( mask, m_externalContour.GetContourPoints(), CV_RGB(255,255,255), CV_RGB(255,255,255),0, CV_FILLED, 8,
					offset );

	// draw internal contours
	t_contourList::iterator it = m_internalContours.begin();
	while(it != m_internalContours.end() )
	{
		cvDrawContours( mask, (*it).GetContourPoints(), CV_RGB(0,0,0), CV_RGB(0,0,0),0, CV_FILLED, 8,
					offset );
		it++;
	}

	cvSetImageROI( image, m_boundingBox );
	cvAvgSdv( image, &mean, &std, mask );
	
	m_meanGray = mean.val[0];
	m_stdDevGray = std.val[0];

	cvReleaseImage( &mask );
	cvResetImageROI( image );

	return m_meanGray;
}

// 以点center为旋转中心，对src旋转angle度并缩放factor倍。
void RotateImage(IplImage *src, IplImage *dst, CvPoint center, float angle,
		float factor) {
	float m[6];
	CvMat mat = cvMat(2, 3, CV_32FC1, m);
	m[0] = (float) (factor * cos(-angle * CV_PI / 180.));
	m[1] = (float) (factor * sin(-angle * CV_PI / 180.));
	m[2] = center.x;
	m[3] = -m[1];
	m[4] = m[0];
	m[5] = center.y;
	cvSetZero(dst);
	cvGetQuadrangleSubPix(src, dst, &mat);
}

KalmanSensorCore::KalmanSensorCore(int _n, int _m) {
	n = _n;
	m = _m;
	z = cvCreateMat(m,1,CV_64FC1); cvSetZero(z);
	H = cvCreateMat(m,n,CV_64FC1); cvSetZero(H);
	H_trans = cvCreateMat(n,m,CV_64FC1); cvSetZero(H_trans);
	K = cvCreateMat(n,m,CV_64FC1); cvSetZero(K);
	z_pred = cvCreateMat(m,1,CV_64FC1); cvSetZero(z_pred);
	z_residual = cvCreateMat(m,1,CV_64FC1); cvSetZero(z_residual);
	x_gain = cvCreateMat(n,1,CV_64FC1); cvSetZero(x_gain);
}