C++ cvGetSubRect函数代码示例

void asef_initialze(AsefEyeLocator *asef, const char *file_name){

  load_asef_filters(file_name, &asef->n_rows, &asef->n_cols, &asef->lrect, 
    &asef->rrect, &asef->lfilter, &asef->rfilter);


  asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
  asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);

  asef->image = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
  asef->image_tile = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1);

  asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
  asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);

  asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
  asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);

  cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0);
  cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0);

  cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect);
  cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect);

  asef->lut = cvCreateMat(256, 1, CV_32FC1);
  for (int i = 0; i<256; i++){
    cvmSet(asef->lut, i, 0, 1.0 + i);
  }
  cvLog(asef->lut, asef->lut);
}

/// <summary>
///     Given image of single character and bounding box,
///     resizes it to new_width and new_height, and if printResult is 1, prints result after running k-nearest algorithm.
/// </summary>
/// <params name="imsSrc">
///     Source image which has to be processed.
/// </params>
/// <params name="new_width">
///     Width to which image has to be resized before running k-nearest algorithm in it.
/// </params>
/// <params name="new_height">
///     Height to which image has to be resized before running k-nearest algorithm in it.
/// </params>
/// <params name="printResult">
///     Indicates whether result has be printed, if its non-zero result are printed after running k-neares algorithm.
/// </params>
/// <returns> Result after classifying image. </returns>
float OCR::process(IplImage* imgSrc, int new_width, int new_height, int printResult, CvRect bb)
{
    IplImage* result;
	IplImage* scaledResult;

	CvMat data;
	CvMat dataA;
	CvRect bba;//bounding box maintain aspect ratio.
	//Get bounding box data and no with aspect ratio, the x and y can be corrupted
	cvGetSubRect(imgSrc, &data, cvRect(bb.x, bb.y, bb.width, bb.height));
	//Create image with this data with width and height with aspect ratio 1
	//then we get highest size betwen width and height of our bounding box
	int size=(bb.width>bb.height)?bb.width:bb.height;
	result=cvCreateImage( cvSize( size, size ), 8, 1 );
	cvSet(result,CV_RGB(255,255,255),NULL);
	//Copy data to center of image
	int x=(int)floor((float)(size-bb.width)/2.0f);
	int y=(int)floor((float)(size-bb.height)/2.0f);

	//Get center of the result into dataA.
	cvGetSubRect(result, &dataA, cvRect(x,y,bb.width, bb.height));
	cvCopy(&data, &dataA, NULL);
	//Scale result
	scaledResult=cvCreateImage( cvSize( new_width, new_height ), 8, 1 );
	cvResize(result, scaledResult, CV_INTER_NN);
	//Return processed data
	return print(*scaledResult, printResult);
}

int main(int argc, char** argv) {
	int M1 = 2;
	int M2 = 2;
	int N1 = 2;
	int N2 = 2;
	// initialize A and B
	//
	CvMat* A = cvCreateMat(M1, N1, CV_32F);
	CvMat* B = cvCreateMat(M2, N2, A->type);

	// it is also possible to have only abs(M2-M1)+1×abs(N2-N1)+1
	// part of the full convolution result
	CvMat* conv = cvCreateMat(A->rows + B->rows - 1, A->cols + B->cols - 1,
			A->type);

	int dft_M = cvGetOptimalDFTSize(A->rows + B->rows - 1);
	int dft_N = cvGetOptimalDFTSize(A->cols + B->cols - 1);

	CvMat* dft_A = cvCreateMat(dft_M, dft_N, A->type);
	CvMat* dft_B = cvCreateMat(dft_M, dft_N, B->type);
	CvMat tmp;

	// copy A to dft_A and pad dft_A with zeros
	//
	cvGetSubRect(dft_A, &tmp, cvRect(0, 0, A->cols, A->rows));
	cvCopy(A, &tmp);
	cvGetSubRect(dft_A, &tmp,
			cvRect(A->cols, 0, dft_A->cols - A->cols, A->rows));
	cvZero(&tmp);

	// no need to pad bottom part of dft_A with zeros because of
	// use nonzero_rows parameter in cvDFT() call below
	//
	cvDFT(dft_A, dft_A, CV_DXT_FORWARD, A->rows);

	// repeat the same with the second array
	//
	cvGetSubRect(dft_B, &tmp, cvRect(0, 0, B->cols, B->rows));
	cvCopy(B, &tmp);
	cvGetSubRect(dft_B, &tmp,
			cvRect(B->cols, 0, dft_B->cols - B->cols, B->rows));
	cvZero(&tmp);

	// no need to pad bottom part of dft_B with zeros because of
	// use nonzero_rows parameter in cvDFT() call below
	//
	cvDFT(dft_B, dft_B, CV_DXT_FORWARD, B->rows);

	// or CV_DXT_MUL_CONJ to get correlation rather than convolution 
	//
	cvMulSpectrums(dft_A, dft_B, dft_A, 0);

	// calculate only the top part
	//
	cvDFT(dft_A, dft_A, CV_DXT_INV_SCALE, conv->rows);
	cvGetSubRect(dft_A, &tmp, cvRect(0, 0, conv->cols, conv->rows));

	cvCopy(&tmp, conv);
	return 0;
}

int asef_initialze(AsefEyeLocator *asef, const char *asef_file_name, const char *fd_file_name){

	if ( !asef || !asef_file_name || !fd_file_name || 
		strlen(asef_file_name)==0 || strlen(fd_file_name)==0)
		return -1;

  // For face detection:
	asef->face_detection_buffer = cvCreateMemStorage(0);
	asef->face_detection_classifier = fd_load_detector( fd_file_name );

	if ( !asef->face_detection_classifier )
		return -1;

  // For asef eye locator:

	if ( load_asef_filters(asef_file_name, &asef->n_rows, &asef->n_cols, &asef->lrect, 
		&asef->rrect, &asef->lfilter, &asef->rfilter) )
		return -1;

	asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
	asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);

	asef->scaled_face_image_32fc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
	asef->scaled_face_image_8uc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1);

	asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);
	asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1);

	asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);
	asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1);

	asef->lut = cvCreateMat(256, 1, CV_32FC1);

	if ( !(asef->lfilter_dft && asef->rfilter_dft && asef->scaled_face_image_32fc1 && 
		asef->scaled_face_image_8uc1 && asef->lcorr && asef->rcorr && asef->lroi && 
		asef->rroi && asef->lut) ){
		return -1;
}

cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0);
cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0);

cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect);
cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect);


for (int i = 0; i<256; i++){
	cvmSet(asef->lut, i, 0, 1.0 + i);
}
cvLog(asef->lut, asef->lut);

return 0;
}

////////////////////////perform fourier transform//////////////////////////////////////////////////
//fft2
// code comes from http://www.opencv.org.cn/
void CLightSet::fft2(IplImage *src,CvMat *dst)
{
	IplImage * realInput;
	IplImage * imaginaryInput;
	IplImage * complexInput;
	int dft_M, dft_N;
	CvMat* dft_A, tmp;
	IplImage * image_Re;
	IplImage * image_Im;

	realInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 1);
	imaginaryInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 1);
	complexInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 2);

	cvScale(src, realInput, 1.0, 0.0);
	cvZero(imaginaryInput);
	cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);

// 	dft_M = cvGetOptimalDFTSize( src->height - 1 );
// 	dft_N = cvGetOptimalDFTSize( src->width - 1 );

	dft_M =src->height;
	dft_N =src->width ;

	dft_A = cvCreateMat( dft_M, dft_N, CV_32FC2 );
	image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_32F, 1);
	image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_32F, 1);

	// copy A to dft_A and pad dft_A with zeros
	cvGetSubRect( dft_A, &tmp, cvRect(0,0, src->width, src->height));
	cvCopy( complexInput, &tmp, NULL );
	if( dft_A->cols > src->width )
	{
		cvGetSubRect( dft_A, &tmp, cvRect(src->width,0, dft_A->cols - src->width, src->height));
		cvZero( &tmp );
	}

	// no need to pad bottom part of dft_A with zeros because of
	// use nonzero_rows parameter in cvDFT() call below

	cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );

	cvCopy(dft_A,dst);

	cvReleaseImage(&realInput);
	cvReleaseImage(&imaginaryInput);
	cvReleaseImage(&complexInput);
	cvReleaseImage(&image_Re);
	cvReleaseImage(&image_Im);

}

// Rearrange the quadrants of Fourier image so that the origin is at
// the image center
// src & dst arrays of equal size & type
void
cvShiftDFT(CvArr *src_arr, CvArr *dst_arr )
{
  CvMat *tmp = NULL;
  CvMat q1stub, q2stub;
  CvMat q3stub, q4stub;
  CvMat d1stub, d2stub;
  CvMat d3stub, d4stub;
  CvMat *q1, *q2, *q3, *q4;
  CvMat *d1, *d2, *d3, *d4;

  CvSize size = cvGetSize(src_arr);
  CvSize dst_size = cvGetSize(dst_arr);
  int cx, cy;

  if(dst_size.width != size.width ||
     dst_size.height != size.height){
    cvError( CV_StsUnmatchedSizes, "cvShiftDFT", "Source and Destination arrays must have equal sizes", __FILE__, __LINE__ );
  }

  if(src_arr==dst_arr){
    tmp = rb_cvCreateMat(size.height/2, size.width/2, cvGetElemType(src_arr));
  }

  cx = size.width/2;
  cy = size.height/2; // image center

  q1 = cvGetSubRect( src_arr, &q1stub, cvRect(0,0,cx, cy) );
  q2 = cvGetSubRect( src_arr, &q2stub, cvRect(cx,0,cx,cy) );
  q3 = cvGetSubRect( src_arr, &q3stub, cvRect(cx,cy,cx,cy) );
  q4 = cvGetSubRect( src_arr, &q4stub, cvRect(0,cy,cx,cy) );
  d1 = cvGetSubRect( src_arr, &d1stub, cvRect(0,0,cx,cy) );
  d2 = cvGetSubRect( src_arr, &d2stub, cvRect(cx,0,cx,cy) );
  d3 = cvGetSubRect( src_arr, &d3stub, cvRect(cx,cy,cx,cy) );
  d4 = cvGetSubRect( src_arr, &d4stub, cvRect(0,cy,cx,cy) );

  if(src_arr!=dst_arr){
    if( !CV_ARE_TYPES_EQ( q1, d1 )){
      cvError( CV_StsUnmatchedFormats, "cvShiftDFT", "Source and Destination arrays must have the same format", __FILE__, __LINE__ );
    }
    cvCopy(q3, d1, 0);
    cvCopy(q4, d2, 0);
    cvCopy(q1, d3, 0);
    cvCopy(q2, d4, 0);
  }
  else{
    cvCopy(q3, tmp, 0);
    cvCopy(q1, q3, 0);
    cvCopy(tmp, q1, 0);
    cvCopy(q4, tmp, 0);
    cvCopy(q2, q4, 0);
    cvCopy(tmp, q2, 0);
  }

  if (tmp != NULL)
  {
	cvReleaseMat(&tmp);
  }
}

void GenerateAffineTransformFromPose(CvSize size, CvAffinePose pose, CvMat* transform)
{
	CvMat* temp = cvCreateMat(3, 3, CV_32FC1);
	CvMat* final = cvCreateMat(3, 3, CV_32FC1);
	cvmSet(temp, 2, 0, 0.0f);
	cvmSet(temp, 2, 1, 0.0f);
	cvmSet(temp, 2, 2, 1.0f);

	CvMat rotation;
	cvGetSubRect(temp, &rotation, cvRect(0, 0, 3, 2));

	cv2DRotationMatrix(cvPoint2D32f(size.width/2, size.height/2), pose.phi, 1.0, &rotation);
	cvCopy(temp, final);

	cvmSet(temp, 0, 0, pose.lambda1);
	cvmSet(temp, 0, 1, 0.0f);
	cvmSet(temp, 1, 0, 0.0f);
	cvmSet(temp, 1, 1, pose.lambda2);
	cvmSet(temp, 0, 2, size.width/2*(1 - pose.lambda1));
	cvmSet(temp, 1, 2, size.height/2*(1 - pose.lambda2));
	cvMatMul(temp, final, final);

	cv2DRotationMatrix(cvPoint2D32f(size.width/2, size.height/2), pose.theta - pose.phi, 1.0, &rotation);
	cvMatMul(temp, final, final);

	cvGetSubRect(final, &rotation, cvRect(0, 0, 3, 2));
	cvCopy(&rotation, transform);

	cvReleaseMat(&temp);
	cvReleaseMat(&final);
}

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;
}

static float CalcAverageMask(CvBlob* pBlob, IplImage* pImgFG )
{   /* Calculate sum of mask: */
    double  Area, Aver = 0;
    CvRect  r;
    CvMat   mat;

    if(pImgFG==NULL) return 0;

    r.x = cvRound(pBlob->x - pBlob->w*0.5);
    r.y = cvRound(pBlob->y - pBlob->h*0.5);
    r.width = cvRound(pBlob->w);
    r.height = cvRound(pBlob->h);
    Area = r.width*r.height;
    if(r.x<0){r.width += r.x;r.x = 0;}
    if(r.y<0){r.height += r.y;r.y = 0;}
    if((r.x+r.width)>=pImgFG->width){r.width=pImgFG->width-r.x-1;}
    if((r.y+r.height)>=pImgFG->height){r.height=pImgFG->height-r.y-1;}

    if(r.width>0 && r.height>0)
    {
        double Sum = cvSum(cvGetSubRect(pImgFG,&mat,r)).val[0]/255.0;
        assert(Area>0);
        Aver = Sum/Area;
    }
    return (float)Aver;
}   /* Calculate sum of mask. */

float basicOCR::classify(IplImage* img, int showResult)//第二个参数主要用来控制是测试训练样本还是手写识别
{
	IplImage prs_image;
	CvMat data;
	CvMat* nearest=cvCreateMat(1,K,CV_32FC1);
	float result;
	//处理输入的图像
	prs_image = preprocessing(img, size, size);
	
	//Set data 
	IplImage* img32 = cvCreateImage( cvSize( size, size ), IPL_DEPTH_32F, 1 );
	cvConvertScale(&prs_image, img32, 0.0039215, 0);
	cvGetSubRect(img32, &data, cvRect(0,0, size,size));
	CvMat row_header, *row1;
	row1 = cvReshape( &data, &row_header, 0, 1 );

	result=knn->find_nearest(row1,K,0,0,nearest,0);
	
	int accuracy=0;
	for(int i=0;i<K;i++)
	{
		if( (nearest->data.fl[i]) == result)
                    accuracy++;
	}
	float pre=100*((float)accuracy/(float)K);
	char out =  result;
	if(showResult==1)
	{
		printf("|\t    %c    \t| \t    %.2f%%  \t| \t %d of %d \t| \n",out,pre,accuracy,K);
		printf(" ------------------------------------------------------------------------\n");
	}

	return result;

}

void asef_locate_eyes(AsefEyeLocator *asef, IplImage *image, CvRect face_rect, CvPoint *leye, CvPoint *reye){
  asef->face_img.cols = face_rect.width;
  asef->face_img.rows = face_rect.height;
  asef->face_img.type = CV_8UC1;
  asef->face_img.step = face_rect.width;

  cvGetSubRect(image, &asef->face_img, face_rect);

  double xscale = ((double)asef->image_tile->cols)/((double)asef->face_img.cols);
  double yscale = ((double)asef->image_tile->rows)/((double)asef->face_img.rows);

  cvResize(&asef->face_img, asef->image_tile, CV_INTER_LINEAR);

  cvLUT(asef->image_tile, asef->image, asef->lut);

  cvDFT(asef->image, asef->image, CV_DXT_FORWARD, 0);
  cvMulSpectrums(asef->image, asef->lfilter_dft, asef->lcorr, CV_DXT_MUL_CONJ);
  cvMulSpectrums(asef->image, asef->rfilter_dft, asef->rcorr, CV_DXT_MUL_CONJ);

  cvDFT(asef->lcorr, asef->lcorr, CV_DXT_INV_SCALE, 0);
  cvDFT(asef->rcorr, asef->rcorr, CV_DXT_INV_SCALE, 0);

  cvMinMaxLoc(asef->lroi, NULL, NULL, NULL, leye, NULL);
  cvMinMaxLoc(asef->rroi, NULL, NULL, NULL, reye, NULL);

  leye->x = (asef->lrect.x + leye->x)/xscale + face_rect.x;
  leye->y = (asef->lrect.y + leye->y)/yscale + face_rect.y;
  reye->x = (asef->rrect.x + reye->x)/xscale + face_rect.x;
  reye->y = (asef->rrect.y + reye->y)/yscale + face_rect.y;
}

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 asef_locate_eyes(AsefEyeLocator *asef){
	asef->face_image.cols = asef->face_rect.width;
	asef->face_image.rows = asef->face_rect.height;
	asef->face_image.type = CV_8UC1;
	asef->face_image.step = asef->face_rect.width;

	cvGetSubRect(asef->input_image, &asef->face_image, asef->face_rect);

	double xscale = ((double)asef->scaled_face_image_8uc1->cols)/((double)asef->face_image.cols);
	double yscale = ((double)asef->scaled_face_image_8uc1->rows)/((double)asef->face_image.rows);

	cvResize(&asef->face_image, asef->scaled_face_image_8uc1, CV_INTER_LINEAR);

	cvLUT(asef->scaled_face_image_8uc1, asef->scaled_face_image_32fc1, asef->lut);

	cvDFT(asef->scaled_face_image_32fc1, asef->scaled_face_image_32fc1, CV_DXT_FORWARD, 0);
	cvMulSpectrums(asef->scaled_face_image_32fc1, asef->lfilter_dft, asef->lcorr, CV_DXT_MUL_CONJ);
	cvMulSpectrums(asef->scaled_face_image_32fc1, asef->rfilter_dft, asef->rcorr, CV_DXT_MUL_CONJ);

	cvDFT(asef->lcorr, asef->lcorr, CV_DXT_INV_SCALE, 0);
	cvDFT(asef->rcorr, asef->rcorr, CV_DXT_INV_SCALE, 0);

	cvMinMaxLoc(asef->lroi, NULL, NULL, NULL, &asef->left_eye, NULL);
	cvMinMaxLoc(asef->rroi, NULL, NULL, NULL, &asef->right_eye, NULL);

	asef->left_eye.x = (asef->lrect.x + asef->left_eye.x)/xscale + asef->face_rect.x;
	asef->left_eye.y = (asef->lrect.y + asef->left_eye.y)/yscale + asef->face_rect.y;
	asef->right_eye.x = (asef->rrect.x + asef->right_eye.x)/xscale + asef->face_rect.x;
	asef->right_eye.y = (asef->rrect.y + asef->right_eye.y)/yscale + asef->face_rect.y;
}

/// <summary>
///     Classifies the given prs_image by running k-nearest algorithm and prints the result.
/// </summary>
/// <param name="prs_image">
///     IplImage to be classified.
/// </param>
/// <param name="showResult">
///     If its 1, then prints result after classifying.
/// </param>
/// <returns> Result after classifying given image. </returns>
float OCR::print(IplImage prs_image, int showResult)
{
    float result;
    CvMat data;
    CvMat* nearest=cvCreateMat(1,K,CV_32FC1);
    //Set data
	IplImage* img32 = cvCreateImage( cvSize( size, size ), IPL_DEPTH_32F, 1 );
	cvConvertScale(&prs_image, img32, 0.0039215, 0);
	cvGetSubRect(img32, &data, cvRect(0,0, size,size));
	CvMat row_header, *row1;
	row1 = cvReshape( &data, &row_header, 0, 1 );

	result=knn->find_nearest(row1,K,0,0,nearest,0);
	if(showResult == 1)
	{
	    char r = result;
        int accuracy=0;
        for(int i=0;i<K;i++)
        {
            if( nearest->data.fl[i] == result)
                accuracy++;
        }

        printf("%c ",r);
//        float pre=100*((float)accuracy/(float)K);
//        printf("|\t%c\t| \t%.2f%%  \t| \t%d of %d \t",r,pre,accuracy,K);
//        printf(" \n---------------------------------------------------------------\n");
	}

	return result;
}

void event_mouse(int button, int state, int x, int y) {
    int err;
    if (state == GLUT_DOWN) { // Mouse down = find template
        // Do hough transform to find ball center and radius
        struct frame *fr = get_frame(active_window->frames, active_window->cur);
        err = houghTransform(active_window, active_window->cur, x, y);
        if (err) {
            return;
        }
        fr->flag |= HAS_HOUGH;
        active_window->guess.x = fr->hough.x;
        active_window->guess.y = fr->hough.y;

        // Make a subimage containing the template
        CvRect r = cvRect(fr->hough.x-fr->hough.radius, fr->hough.y-fr->hough.radius, fr->hough.radius*2, fr->hough.radius*2);
        CvMat *sub = cvCreateMatHeader(fr->hough.radius*2, fr->hough.radius*2, CV_32FC1);
        cvGetSubRect(fr->image, sub, r);
        active_window->tmpl = sub;

        // Match (could be left out)
        templateMatch(active_window, active_window->cur, MARGIN, sub);
        fr->flag |= HAS_MATCH;
        glutPostRedisplay();

        // Calculate meters per pixel
        active_window->mpp = atof(active_window->argv[2])/(fr->hough.radius*2);
        printf("Getting mpp: %f/%f = %f\n", atof(active_window->argv[2]), fr->hough.radius*2, active_window->mpp);
    }
}