예제 #1
0
void Panoramic::ShowStitch(IplImage *profile,IplImage *center)
{
	double profileFaceDate = 0.;
	double Alpha = 0.5;//allocate middle of stich image a half of center and lateral image
	double Blendling = 0.;

	for(int j = 0;j < m_height;j++)
	{
		for(int i = 0;i < m_width;i++)
		{
			double linePosition = m_slope*i+m_intercept-j;

			profileFaceDate = cvGetReal2D(profile,j,i);

			if(linePosition <= -m_lineT)
			{
				cvSetReal2D(m_PanoramicFace,j,i,profileFaceDate);
			}

			else if(linePosition > -m_lineT && linePosition < m_lineT)
			{
				double getAlpha = LinearBlending(m_lineT,m_slope*i+m_intercept-j,Alpha);
				double getBeta  = 1-getAlpha;

				Blendling = getAlpha*cvGetReal2D(center,j,i) + getBeta*profileFaceDate;

				if(Blendling > 255)	  Blendling = 255;
				else if(Blendling < 0)Blendling = 0;
				cvSetReal2D(m_PanoramicFace,j,i,Blendling) ;
			}
		}
	}
}
예제 #2
0
void findExtrinsic(std::vector<CvPoint2D32f>& corners, int rows, int cols)
{

  CvMat *image_points_ex = cvCreateMat( corners.size(), 2, CV_64FC1);

  for (uint j = 0; j < corners.size(); j++){
    cvSetReal2D( image_points_ex, j, 0, corners[j].x);
    cvSetReal2D( image_points_ex, j, 1, corners[j].y);
  }

  //int views = 1;

  CvMat *object_points_ex = cvCreateMat( corners.size(), 3, CV_64FC1);
  for (uint j = 0; j < corners.size(); j++){
                cvSetReal2D( object_points_ex, j, 0, ( j % rows) * GRID_SIZE );
                cvSetReal2D( object_points_ex, j, 1, ( j / rows) * GRID_SIZE );
                cvSetReal2D( object_points_ex, j, 2, 0.0 );
        }

  //cvSetReal2D( itsCameraTranslation, 0, 2, 782.319961 );
  cvFindExtrinsicCameraParams2( object_points_ex,
      image_points_ex,
      itsIntrinsicMatrix,
      itsDistortionCoeffs,
      itsCameraRotation,
      itsCameraTranslation);

        cvReleaseMat( &image_points_ex);
  cvReleaseMat( &object_points_ex);

}
예제 #3
0
/**	@Specifically designed for this program 
	*so it is include m_lineT to reduce unnecessary operation*/
void Panoramic::AffineTransform(IplImage *src,IplImage *dst,CvMat *Matrix)
{
	for(int j = 0; j < m_height;j++)
	{
		for(int i = 0 ; i < m_width;i++)
		{
			double linePosition = m_slope*i + m_intercept-j;

			if(linePosition <= m_lineT )  //
			{
				int x  = i*cvGetReal2D(Matrix,0,0) + j*cvGetReal2D(Matrix,0,1) + cvGetReal2D(Matrix,0,2)*1.0;
				int y  = i*cvGetReal2D(Matrix,1,0) + j*cvGetReal2D(Matrix,1,1) + cvGetReal2D(Matrix,1,2)*1.0;
					
				if(x > 0 && y > 0 && x < m_width && y < m_height)
				{
					double pixel = cvGetReal2D(src,y,x);
					cvSetReal2D(dst,j,i,pixel) ;
				}
				else
				{
					cvSetReal2D(dst,j,i,0) ;
				}
			}
		}
	}
}
예제 #4
0
void mitk::UndistortCameraImage::SetUndistortImageFastInfo(float in_dF1, float in_dF2,
                                                 float in_dPrincipalX, float in_dPrincipalY,
                                                 float in_Dist[4], float ImageSizeX, float ImageSizeY)
{
  //create new matrix
  m_DistortionCoeffs  = cvCreateMat(4, 1, CV_64FC1);
  m_CameraMatrix      = cvCreateMat(3, 3, CV_64FC1);


  //set the camera matrix [fx 0 cx; 0 fy cy; 0 0 1].
  cvSetReal2D(m_CameraMatrix, 0, 0, in_dF1);
  cvSetReal2D(m_CameraMatrix, 0, 1, 0.0);
  cvSetReal2D(m_CameraMatrix, 0, 2, in_dPrincipalX);

  cvSetReal2D(m_CameraMatrix, 1, 0, 0.0);
  cvSetReal2D(m_CameraMatrix, 1, 1, in_dF2);
  cvSetReal2D(m_CameraMatrix, 1, 2, in_dPrincipalY);

  cvSetReal2D(m_CameraMatrix, 2, 0, 0.0);
  cvSetReal2D(m_CameraMatrix, 2, 1, 0.0);
  cvSetReal2D(m_CameraMatrix, 2, 2, 1.0);

  //set distortions coefficients
  cvSetReal1D(m_DistortionCoeffs, 0, in_Dist[0]);
  cvSetReal1D(m_DistortionCoeffs, 1, in_Dist[1]);
  cvSetReal1D(m_DistortionCoeffs, 2, in_Dist[2]);
  cvSetReal1D(m_DistortionCoeffs, 3, in_Dist[3]);

  m_mapX = cvCreateMat(ImageSizeY, ImageSizeX, CV_32FC1);
  m_mapY = cvCreateMat(ImageSizeY, ImageSizeX, CV_32FC1);

  //cv::initUndistortRectifyMap(m_CameraMatrix, m_DistortionCoeffs, m_mapX, m_mapY);
  cvInitUndistortMap(m_CameraMatrix, m_DistortionCoeffs, m_mapX, m_mapY);
}
예제 #5
0
/* This is the measurement mapping used by the UKF, i.e.
 * z(t) = h(x(t), n(t))
 *
 * In this case, z is a vector with (x,y) position and heading and
 * noise is additive. */
void beluga_measurement(const CvMat* x_k,
                        const CvMat* n_k,
                        CvMat* z_k)
{
	unsigned int nrows = z_k->rows;
	unsigned int nmeas = (nrows-1)/3;
	if( (3*nmeas) != (nrows-1))
	{
		fprintf(stderr, "beluga_measurement error:  "
			"Number of rows in z is incorrect.  Must be 3*n+1.\n");
		return;
	}

	/* measurement should be (x, y, theta) repeated nmeas times then z */
	for(unsigned int i = 0; i < nmeas; i++)
	{
        double x = cvGetReal2D(x_k, BELUGA_STATE_X, 0);
        double y = cvGetReal2D(x_k, BELUGA_STATE_Y, 0);
        double theta = cvGetReal2D(x_k, BELUGA_STATE_THETA, 0);

        double x_noise = 0;
        double y_noise = 0;
        double theta_noise = 0;
        if(n_k)
        {
            x_noise = cvGetReal2D(n_k, (BELUGA_NUM_MEAS-1)*i + BELUGA_MEAS_X, 0);
            y_noise = cvGetReal2D(n_k, (BELUGA_NUM_MEAS-1)*i + BELUGA_MEAS_Y, 0);
            theta_noise = cvGetReal2D(n_k, (BELUGA_NUM_MEAS-1)*i + BELUGA_MEAS_THETA, 0);
        }

        x += x_noise;
        y += y_noise;
        theta += theta_noise;
        
		cvSetReal2D(z_k, (BELUGA_NUM_MEAS-1)*i+BELUGA_MEAS_X,     0, x);
		cvSetReal2D(z_k, (BELUGA_NUM_MEAS-1)*i+BELUGA_MEAS_Y,     0, y);
		cvSetReal2D(z_k, (BELUGA_NUM_MEAS-1)*i+BELUGA_MEAS_THETA, 0, theta);
	}
    double z = cvGetReal2D(x_k, BELUGA_STATE_Z, 0);    
    double z_noise = 0;
    if(n_k)
    {
        /* z noise will be the last element */
        z_noise = cvGetReal2D(n_k, n_k->rows - 1, 0);
    }

    z += z_noise;

	/* NOTE:  Specifically not constraining z here, b/c the constraint
	 * induces an artificial disturbance near the boundaries.  The constraint
	 * is applied afterwords. */

    cvSetReal2D(z_k, nrows-1, 0, z);
}
예제 #6
0
/*
 * ofxNMPTFaceTracker
 * 
 * @param width int						Input frame width
 * @param height int					Input frame height
 * @param numScales int					Number of Patches in the Image Patch Pyramid.
 * @param gridXSize						SubImage size x
 * @param gridYSize						SubImage size y
 * @param haarDetectorXMLFile string	The Haar detector xml file
 *
 */
ofxNMPTFaceTracker::ofxNMPTFaceTracker(int width, int height, int numScales, int gridXSize, int gridYSize, string haarDetectorXMLFile) {
	
	int scaleGridCells[numScales]; 
	int ngrid_pts = 1; 
	
	for (int i = 0; i < numScales; i++) {
		int inc = ngrid_pts+2; 
		int halfwidth = (numScales - i - 1)*inc + ngrid_pts;
		
		scaleGridCells[i] =  halfwidth*2+1; //,9,15,21
	}
	
	int numGridPoints = scaleGridCells[0]; 
	
	// The size of the images that will be given to the IPP to turn into MIPOMDP observations. 
	// This allocates memory for underlying data, but it can be changed easily later if needed 
	// without recreating the object by calling the changeInputSize() functions.
	CvSize inputImageSize = cvSize(width, height); 
	
	// The common size to which all image patches will be reduced, creating the foveation effect. 
	// The smaller subImageSize is, the faster search is, and the more extreme the effect of foveation. 
	// This allocates memory for underlying data, but it can be changed easily later if needed without 
	// recreating the object by calling the changeInputSize() functions.
	CvSize subImageSize = cvSize(gridXSize, gridYSize); 
	
	// Size of the discretization of the image. The number of POMDP states is the product of the 
	// demensions of this size (e.g. 21x21).
	CvSize gridSize = cvSize(numGridPoints, numGridPoints); 
	
	// A matrix that describes the size and shape of each level (patch) of the IP Pyramid. 
	// This must be a matrix with size [numSubImages x 2]. Each row contains the width and height 
	// of the corresponding levels. These should be in order of *decreasing* size, so that the largest 
	// Image Patch is first. For example, in Butko and Movellan CVPR 2009, we used [21 21; 15 15; 9 9; 3 3]. 
	// Finaly, note that it is not necessary that the largest patch cover the entire image. However, when the 
	// largest patch is the same size as grid-cell-matrix, special optimizations become available that reduce 
	// the complexity of the algorithm when the same image, or same frame of video, is fixated multiple times.
	CvMat* subImageGridPoints = cvCreateMat(numScales, 2, CV_32SC1); 
	
	for (int i = 0; i < numScales; i++) {
		cvSetReal2D(subImageGridPoints, i, 0, scaleGridCells[i]); 
		cvSetReal2D(subImageGridPoints, i, 1, scaleGridCells[i]); 
	}
	
	// Instatiate MOPOMDP as tracker
	faceTracker = new MIPOMDP(
							  cvSize(width, height), 
							  subImageSize,
							  gridSize,
							  numScales,
							  subImageGridPoints,
							  ofToDataPath(haarDetectorXMLFile).c_str()
	);
	
}
예제 #7
0
static void dance_measurement(const CvMat* x_k,
                              const CvMat* n_k,
                              CvMat* z_k)
{
    cvSetReal2D(z_k, 0, 0, cvGetReal2D(x_k, 0, 0));
    cvSetReal2D(z_k, 1, 0, cvGetReal2D(x_k, 1, 0));

    /* as above, skip this step when n_k is null */
    if(n_k)
    {
        cvAdd(z_k, n_k, z_k);
    }
}
예제 #8
0
void GaborImage::CalculateKernel(int Orientation, int Frequency) {
	Init();
	
	float real, img;
	
	for (int x = -(GaborWidth - 1) / 2; x < (GaborWidth - 1) / 2 + 1; x++)
		for (int y = -(GaborHeight - 1) / 2; y < (GaborHeight - 1) / 2 + 1; y++)
		{
			real = KernelRealPart(x, y, Orientation, Frequency);
			img = KernelImgPart(x, y, Orientation, Frequency);
			
			cvSetReal2D(KernelRealData, x + (GaborWidth - 1) / 2, y + (GaborHeight - 1) / 2, real);
			cvSetReal2D(KernelImgData,  x + (GaborWidth - 1) / 2, y + (GaborHeight - 1) / 2, img);
		}
}
예제 #9
0
void adjustRMatrixAndZForMeasurementSize(CvMat*& R, CvMat*& z, unsigned int nmeas)
{
	if(nmeas == 0)
	{
		return;
	}

	unsigned int nrows_prev = (R)->rows;
	unsigned int nrows_z_prev = (z)->rows;
	if(nrows_prev < 4)
	{
		fprintf(stderr, "adjustRMatrixForMeasurementSize Error:  Existing R is too small.\n");
		return;
	}

	/* x, y, th each meas + z */
	unsigned int nrows_now = 3*nmeas + 1;
	/* same number of measurements -> do nothing */
	if(nrows_now == nrows_prev && nrows_now == nrows_z_prev)
	{
		return;
	}

//	printf("adjR a  %d %d\n", nrows_prev, nrows_now);
	double sx = cvGetReal2D(R, 0, 0);
	double sy = cvGetReal2D(R, 1, 1);
	double sth = cvGetReal2D(R, 2, 2);
	double sz = cvGetReal2D(R, nrows_prev-1, nrows_prev-1);

//	printf("adjR b\n");
	cvReleaseMat(&R);
	cvReleaseMat(&z);
//	printf("adjR c\n");
	R = cvCreateMat(nrows_now, nrows_now, CV_64FC1);
	z = cvCreateMat(nrows_now, 1, CV_64FC1);
//	printf("adjR d\n");
	cvZero(R);
	cvZero(z);
//	printf("adjR e\n");
	for(unsigned int i = 0; i < nmeas; i++)
	{
		cvSetReal2D(R, i*3 + 0, i*3 + 0, sx);
		cvSetReal2D(R, i*3 + 1, i*3 + 1, sy);
		cvSetReal2D(R, i*3 + 2, i*3 + 2, sth);
	}
//	printf("adjR f\n");
	cvSetReal2D(R, nrows_now-1, nrows_now-1, sz);
}
예제 #10
0
파일: autoseg.cpp 프로젝트: viscenter/educe
void radial_sample(int width, int height, char* data, IplImage *unwrapped, int slice)
{
	IplImage *cvcast = cvCreateImageHeader(cvSize(width, height),
			IPL_DEPTH_8U, 1);
	cvcast->imageData = data;

	// cvSaveImage("slice.png",cvcast);
	
	CvPoint center = cvPoint(cx,cy);

	unsigned char* linebuf;
	for(int sample = 0; sample < RADIAL_SAMPLES; sample++) {
		float theta = ((float)sample)*((2.0*PI)/(float)RADIAL_SAMPLES);
		CvPoint outer = calc_ray_outer(theta, center);

		// printf("%g:\t%d,%d\n", theta*(180.0/PI), outer.x, outer.y);
		cvClipLine(cvSize(width, height), &outer, &center);
		int linesize = abs(center.x-outer.x)+abs(center.y-outer.y)+1;
		linebuf = (unsigned char*)malloc(linesize);
		cvSampleLine(cvcast,outer,center,linebuf,4);
		
		IplImage *castline = cvCreateImageHeader(cvSize(linesize,1), IPL_DEPTH_8U, 1);
		castline->imageData = (char*)linebuf;

		IplImage *sobel = cvCreateImage(cvSize(linesize,1), IPL_DEPTH_8U, 1);

		cvSobel(castline, sobel, 1, 0, 3);

		int layer = 0;
		for(int i = 0; (i < linesize) && (layer < MAX_LAYERS); i++) {
			// printf(" %d,", (int)cvGetReal1D(sobel,i));
			if((int)cvGetReal1D(sobel,i) > SOBEL_THRESH) {
				int max = 0, max_i = 0;
				for(; i < linesize; i++) {
					int curval = (int)cvGetReal1D(sobel,i);
					if(curval == 0) break;
					if(curval > max) {
						max = curval;
						max_i = i;
					}
				}
				cvSetReal2D(unwrapped,slice,(layer*RADIAL_SAMPLES)+sample,cvGetReal1D(castline,max_i));
				// printf("%d\t",max);
				layer++;
			}
		}
		// printf("\n");
	
		/*	
		char filename[] = "line000.png";
		sprintf(filename,"line%03d.png",(int)(theta*(180.0/PI)));
		cvSaveImage(filename,sobel);
		*/
		
		cvReleaseImageHeader(&castline);
		cvReleaseImage(&sobel);

		free(linebuf);
	}
}
void GS_rotate( IplImage* srcImg, IplImage *srcImgRotated, int angle )
{
    int i, j;
    double new_x, new_y, var;    

    int height = srcImg->height;
    int width  = srcImg->width;
    
	double radius = -angle*(M_PI/180.0);
    double sin_value = sin(radius);
    double cos_value = cos(radius);

    int centerX = height/2;
    int centerY = width/2;

    for(i=0; i<height; i++)
    {
        for(j=0; j<width; j++)
        {
            new_x = (i-centerX)*cos_value - (j-centerY)*sin_value + centerX;
            new_y = (i-centerX)*sin_value + (j-centerY)*cos_value + centerY;

            if(new_x < 0 || new_x > height) 
            {
                var = 0.0; 
            } else if(new_y < 0 || new_y > width) {
                var = 0.0; 
            } else {
                var = cvGetReal2D( srcImg, (int)new_x, (int)new_y );
            }

            cvSetReal2D( srcImgRotated, i, j, var );
        }
    }    
}
// Histogram Contrast Stretching
void Filterling ::contrastStretching (IplImage *srcImage, IplImage *dstImage) {
	// histogram연산을 위해 사용할 배열메모리를 할당 
	 unsigned int *histogramArray = new unsigned int[256],
		*sumHistogramArray = new unsigned int[256] ;
	memset (histogramArray, 0, sizeof (unsigned int) * 256) ;
	memset (sumHistogramArray, 0, sizeof (unsigned int) * 256) ;

	// 영상의 histogram을 계산 
	for (size_t i = 0 ; i < srcImage ->height ; i++) 
		for (size_t j = 0 ; j < srcImage ->width ; j++) 
			histogramArray[(unsigned int)cvGetReal2D (srcImage, i, j)]++ ;

	// histogram의 정규화된 합을 계산 
	unsigned int sum = 0 ;
	const float SCALE_FACTOR = 128.0f / (float)(srcImage ->height * srcImage ->width) ;

	for (size_t i = 0 ; i < 256 ; i++) {
		sum += histogramArray[i] ;
		sumHistogramArray[i] = (unsigned int)((sum * SCALE_FACTOR) + 0.5) ;
	}

	// LUT로써 sumHistogramArray 배열을 사용하여 영상을 변환 
	for (size_t i = 0 ; i < srcImage ->height ; i++) 
		for (size_t j = 0 ; j < srcImage ->width ; j++) 
			// pixel indexing
			cvSetReal2D (dstImage, i, j, (double) sumHistogramArray[(unsigned int)cvGetReal2D (srcImage, i, j)]) ;

	delete [] (histogramArray) ;
	delete [] (sumHistogramArray) ;
}
예제 #13
0
int main(int argc, const char * argv[]) {
    CvMat *cmatrix = cvCreateMat(5,5,CV_32FC1);
    float element_3_2 = 7.7;
    *((float*)CV_MAT_ELEM_PTR( *cmatrix, 3,2) ) = element_3_2;
    cvmSet(cmatrix,4,4,0.5000);
    cvSetReal2D(cmatrix,3,3,0.5000);
    
    CvFileStorage* fs1 = cvOpenFileStorage("cfg.xml", 0, CV_STORAGE_WRITE);
    cvWriteInt( fs1, "frame_count", 10 );
    cvStartWriteStruct( fs1, "frame_size", CV_NODE_SEQ );
    cvWriteInt( fs1 , 0, 320 );
    cvWriteInt( fs1 , 0, 200 );
    cvEndWriteStruct( fs1 );
    cvWrite( fs1, "color_cvt_matrix", cmatrix );
    cvReleaseFileStorage( &fs1 );
    
    CvFileStorage* fs2 = cvOpenFileStorage("cfg.xml", 0, CV_STORAGE_READ);
    int frame_count = cvReadIntByName( fs2 , 0, "frame_count");
    CvSeq* s = cvGetFileNodeByName( fs2,0,"frame_size" )->data.seq;
    int frame_width = cvReadInt( (CvFileNode*)cvGetSeqElem(s,0) );
    int frame_height = cvReadInt( (CvFileNode*)cvGetSeqElem(s,1) );
    CvMat* color_cvt_matrix = (CvMat*) cvReadByName( fs2, 0 , "color_cvt_matrix");
    
    printf("color_cvt_matrix: width=%d, height=%d\n",color_cvt_matrix->width, color_cvt_matrix->height );
    printf("frame_count=%d, frame_width=%d, frame_height=%d\n",frame_count,frame_width,frame_height);
    
    cvReleaseFileStorage( &fs2 );
    
    return 0;
}
void CueTemplate::drawgaussianblob(const CvPoint& pos, const CvSize& size) {
	float temp = 1.0;
	temp = (mp_boundedoutputimg->width) / 160.0;
	float K = 2.0 * size.width * temp; // smaller K, smaller circle
	int windowSizeX = cvRound(size.width * temp);
	int windowSizeY = cvRound(size.height * temp);
	int posx = pos.x;
	int posy = pos.y;
	int width = mp_boundedoutputimg->width;
	int height = mp_boundedoutputimg->height;
	cvSetZero(mp_boundedoutputimg);
	for(int x = -windowSizeX; x <= windowSizeX; ++x) {
		for(int y = -windowSizeY; y <= windowSizeY; ++y) {
		
			int tempx = posx + x;
			int tempy = posy + y;

			if(tempx >= 0 && tempy >= 0 && tempx < width && tempy < height) {
				double val = exp(-0.5/K*((float)x*(float)x + (float)y*(float)y));
				cvSetReal2D(mp_boundedoutputimg, tempy, tempx, val);
			}
		
		}
	}
}
예제 #15
0
void ClassifierMLP::Train(std::vector< fvec > samples, ivec labels)
{
	u32 sampleCnt = samples.size();
	if(!sampleCnt) return;
	DEL(mlp);
	dim = samples[0].size();

	CvMat *layers;
//	if(neuronCount == 3) neuronCount = 2; // don't ask me why but 3 neurons mess up everything...

	if(!layerCount || neuronCount < 2)
	{
		layers = cvCreateMat(2,1,CV_32SC1);
		cvSet1D(layers, 0, cvScalar(dim));
		cvSet1D(layers, 1, cvScalar(1));
	}
	else
	{
		layers = cvCreateMat(2+layerCount,1,CV_32SC1);
		cvSet1D(layers, 0, cvScalar(dim));
		cvSet1D(layers, layerCount+1, cvScalar(1));
		FOR(i, layerCount) cvSet1D(layers, i+1, cvScalar(neuronCount));
	}

	u32 *perm = randPerm(sampleCnt);

	CvMat *trainSamples = cvCreateMat(sampleCnt, dim, CV_32FC1);
	CvMat *trainLabels = cvCreateMat(labels.size(), 1, CV_32FC1);
	CvMat *sampleWeights = cvCreateMat(samples.size(), 1, CV_32FC1);
	FOR(i, sampleCnt)
	{
		FOR(d, dim) cvSetReal2D(trainSamples, i, d, samples[perm[i]][d]);
		cvSet1D(trainLabels, i, cvScalar(labels[perm[i]]));
		cvSet1D(sampleWeights, i, cvScalar(1));
	}
예제 #16
0
파일: utils.c 프로젝트: haldai/Logic-Vision
CvScalar myCvPointANNF(IplImage* img, CvPoint p, int size, double l_channel_weight) {
    assert(size%2 == 1);
    CvMat* mat = cvCreateMat(size, size, CV_32FC3);
    CvMat* d = cvCreateMat(size, size, CV_32FC1); 
//    CvMat* w = cvCreateMat(size, size, CV_32FC1);
    
    int rad = (size - 1)/2;

    for (int r = -rad; r <= rad; r++) { // y-axis
	CvPoint center = cvPoint(p.x, p.y + r);
	int y = rad + r;
	for (int rr = -rad; rr <= rad; rr++) { // x-axis
	    CvPoint this = myCvHandleEdgePoint(
		cvPoint(center.x + rr, center.y),
		img->width,
		img->height
		);
	    int x = rad + r;
	    cvSet2D(mat, x, y, cvGet2D(img, this.y, this.x)); // inversed xy
	}
    }
    
    double max_d = .0;
    double sum = .0;
    for (int i = 0; i < size; i++) {
	for (int j = 0; j < size; j++) {
	    double dd = .0;
	    // compute d(i, j)
	    for (int k = 0; k < size; k++) {
		for (int l = 0; l < size; l++) {
		    if (!(k == i && l == j)) {
			dd += euDist(cvGet2D(mat, i, j), cvGet2D(mat, k, l), l_channel_weight);
		    }
		}
	    }
	    if (dd > max_d)
		max_d = dd;
	    sum += dd;
	    cvSetReal2D(d, i, j, dd);
	}
    }

    double denom = max_d*size*size - sum;

    CvScalar re = cvScalar(0, 0, 0, 0);
    for (int i = 0; i < size; i++) {
	for (int j = 0; j < size; j++) {
	    // compute weight
	    double ww = (max_d - cvGetReal2D(d, i, j))/denom;
	    for (int k = 0; k < 4; k++) {
		re.val[k] += ww*cvGet2D(mat, i, j).val[k];
	    }
	}
    }

    cvReleaseMat(&mat);
    cvReleaseMat(&d);

    return re;
}
예제 #17
0
/*!
    \fn CvGabor::creat_kernel()
Create gabor kernel

Parameters:
        None

Returns:
        None

Create 2 gabor kernels - REAL and IMAG, with an orientation and a scale
 */
void CvGabor::creat_kernel()
{
   
    if (IsInit() == false) {perror("Error: The Object has not been initilised in creat_kernel()!\n");}
    else {
      CvMat *mReal, *mImag;
      mReal = cvCreateMat( Width, Width, CV_32FC1);
      mImag = cvCreateMat( Width, Width, CV_32FC1);
     
      /**************************** Gabor Function ****************************/
      int x, y;
      double dReal;
      double dImag;
      double dTemp1, dTemp2, dTemp3;

      for (int i = 0; i < Width; i++)
      {
          for (int j = 0; j < Width; j++)
          {
              x = i-(Width-1)/2;          // (width-1)/2 = anchor
              y = j-(Width-1)/2;
              dTemp1 = (pow(K,2)/pow(Sigma,2))*exp(-(pow((double)x,2)+pow((double)y,2))*pow(K,2)/(2*pow(Sigma,2)));

              dTemp2 = cos(K*cos(Phi)*x + K*sin(Phi)*y) - exp(-(pow(Sigma,2)/2));
              dTemp3 = sin(K*cos(Phi)*x + K*sin(Phi)*y);
              dReal = dTemp1*dTemp2;
              dImag = dTemp1*dTemp3;
              //gan_mat_set_el(pmReal, i, j, dReal);
              //cvmSet( (CvMat*)mReal, i, j, dReal );
                cvSetReal2D((CvMat*)mReal, i, j, dReal );
              //gan_mat_set_el(pmImag, i, j, dImag);
              //cvmSet( (CvMat*)mImag, i, j, dImag );
                cvSetReal2D((CvMat*)mImag, i, j, dImag );

          }
       }
       /**************************** Gabor Function ****************************/
       bKernel = true;
       cvCopy(mReal, Real, NULL);
       cvCopy(mImag, Imag, NULL);
      //printf("A %d x %d Gabor kernel with %f PI in arc is created.\n", Width, Width, Phi/PI);
       cvReleaseMat( &mReal );
       cvReleaseMat( &mImag );
     }
}
예제 #18
0
void ColorDistribution::FeedFrame(IplImage *image)
{
	if(_fReadyToCompute)
		return;

	if(_nWidth == 0 && _nHeight == 0) {
		// Initialize
		_nWidth = image->width;
		_nHeight = image->height;
	}

	// Sampling
	for(int x = 0; x < _nWidth; x++) {
		for(int y = 0; y < _nHeight; y++) {
			CvScalar color = cvGet2D(image, y, x);
			for(int c = 1; c <= 2; c++)
				// Sample only Cr, Cb channels. (or G, R channels.)
				_Sample[x][y][c-1][_nIndex] = color.val[c];
		}
	}

	// Increase index
	_nIndex++;
	if(_nIndex == MAX_HISTORY) {
		_nIndex = 0;
		_fReadyToCompute = true;
	}

	// Compute mean and variance per-pixel
	if(_fReadyToCompute) {
		for(int x = 0; x < _nWidth; x++) {
			for(int y = 0; y < _nHeight; y++) {
				for(int c = 0; c < 2; c++) {
					// Mean
					_Mean[x][y][c] = 0;
					for(int h = 0; h < MAX_HISTORY; h++)
						_Mean[x][y][c] += _Sample[x][y][c][h];
					_Mean[x][y][c] /= ((float)MAX_HISTORY);

					// Variance
					_Var[x][y][c] = 0;
					for(int h = 0; h < MAX_HISTORY; h++)
						_Var[x][y][c] += (pow(_Sample[x][y][c][h] - _Mean[x][y][c], 2));
					_Var[x][y][c] /= ((float)MAX_HISTORY);
				}
			}
		}

		if(!_pMask)
			_pMask = cvCreateImage(cvSize(_nWidth, _nHeight), 8, 1);

		// threshold by variance
		for(int x = 0; x < _nWidth; x++)
			for(int y = 0; y < _nHeight; y++)
				cvSetReal2D(_pMask, y, x, 255 * (_Var[x][y][0]+_Var[x][y][1]) / 10000.0);
	}
}
예제 #19
0
// use k-means to reduce color number
MyQuantifiedImage* kmeansQuantification(IplImage* img, int tableSize) {

    // step 1: transfer image to kmeans samples
    int sample_count = img->height * img->width;
    CvMat* samples = cvCreateMat(sample_count, 1, CV_32FC3);
    CvRNG rng = cvRNG(0xffffffff);

    int idx = 0;
    for (int i = 0; i < img->height; i++) {
	for (int j = 0; j < img->width; j++) {
	    cvSet1D(samples, idx++, cvGet2D(img, i, j));
	}
    }
    
    // step 2: apply kmeans;
    CvMat* labels = cvCreateMat(sample_count, 1, CV_32SC1);
    CvMat* centers = cvCreateMat(tableSize, 1, CV_32FC3);
    cvSetZero(labels);
    cvSetZero(centers);
    
    cvKMeans2(samples, tableSize, labels,
	      cvTermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 
			     10, CV_KMEANS_ACC), 
	      CV_KMEANS_ATTEMPTS, &rng,
	      CV_KMEANS_PP_CENTERS, centers, 0); // flag = KMEANS_PP_CENTERS

    // step 3: rebuild the image
    IplImage* quantImg = cvCreateImage(cvGetSize(img), IPL_DEPTH_32F, 3);
    CvMat* labelImg = cvCreateMat(img->height, img->width, CV_32SC1);
    cvSetZero(quantImg);
    cvSetZero(labelImg);
    
    idx = 0;
    for (int i = 0; i < img->height; i++) {
	for (int j = 0; j < img->width; j++) {
	    int cluster_idx = labels->data.i[idx++];
	    CvScalar color = cvGet1D(centers, cluster_idx);
	    cvSet2D(quantImg, i, j, color);
	    cvSetReal2D(labelImg, i, j, (double) cluster_idx);
	}
    }

    MyQuantifiedImage* re = malloc(sizeof(MyQuantifiedImage));
    re->labelMat = labelImg;
    re->qImg = quantImg;
    re->tableSize = tableSize;
    
    CvScalar* colorTable = calloc(tableSize, sizeof(CvScalar));
    for (int i = 0; i < tableSize; i++) {
	colorTable[i] = cvGet1D(centers, i);
    }
    re->colorTable = colorTable;


    return re;
}
예제 #20
0
CvMat *
get_camera_matrix(stereo_util instance)
{
	CvMat *matrix = cvCreateMat(3, 3, CV_32F);
	cvSetReal2D(matrix, 0, 1, 0.0);
	cvSetReal2D(matrix, 1, 0, 0.0);
	cvSetReal2D(matrix, 2, 0, 0.0);
	cvSetReal2D(matrix, 2, 1, 0.0);
	cvSetReal2D(matrix, 0, 0, instance.fx);
	cvSetReal2D(matrix, 1, 1, instance.fy);
	cvSetReal2D(matrix, 0, 2, instance.xc);
	cvSetReal2D(matrix, 1, 2, instance.yc);
	cvSetReal2D(matrix, 2, 2, 1.0);
	return matrix;
}
예제 #21
0
int main(int argc, char** argv)
{
    CvMat *mat = cvCreateMat(5,5,CV_32FC1);
    float element_3_2 = 7.7;
    *((float*)CV_MAT_ELEM_PTR( *mat, 3,2) ) = element_3_2;
    cvmSet(mat,4,4,0.5000);
    cvSetReal2D(mat,3,3,0.5000);
    float s = sum(mat);
    printf("%f\n",s);
    return 0;
}
예제 #22
0
파일: main.c 프로젝트: lorlor/DIPpro
void showfilter(double *filter,int width,int height){
    IplImage *show=cvCreateImage(cvSize(width, height),8,1);
    for(int i=0;i<width;i++)
        for(int j=0;j<height;j++){
            cvSetReal2D(show, j, i, filter[i*width+j]*255.0);
        }
    cvNamedWindow("Filter", 1);
    cvShowImage("Filter", show);
    cvWaitKey(0);
    cvReleaseImage(&show);

}
예제 #23
0
PABOD_EXPORT float makeDetection (CvMat **results, IplImage *img, Model * model, float thresh, double iouNms)
{

  CvMat *dets = NULL;
  CvMat *boxes = NULL;
  CvMatND *info = NULL;

  if (thresh == POSITIVE_INF)
    thresh = (float)model->getThresh();

  bool found = imgDetect (img, model, thresh, NULL, NEGATIVE_INF, &dets, &boxes, &info);

  int detected = 0;

  if (found)
  {
    int *pick;
    int pickDim;

    nms (&pick, &pickDim, dets, iouNms);

    (*results) = cvCreateMat (pickDim, 6, CV_32FC1);

    for (int i = 0; i < pickDim; i++)
    {
      cvSetReal2D ((*results), i, 0, cvGetReal2D (dets, pick[i], 0));
      cvSetReal2D ((*results), i, 1, cvGetReal2D (dets, pick[i], 1));
      cvSetReal2D ((*results), i, 2, cvGetReal2D (dets, pick[i], 2));
      cvSetReal2D ((*results), i, 3, cvGetReal2D (dets, pick[i], 3));
//cout << cvGetReal2D (dets, pick[i], 4) << "+ " << cvGetReal2D (dets, pick[i], 5) << " |";
      cvSetReal2D ((*results), i, 4, cvGetReal2D (dets, pick[i], 5));
      cvSetReal2D ((*results), i, 5, cvGetReal2D (dets, pick[i], 4));
    }

    detected = pickDim;

    delete[] pick;
  }

	else
		(*results) = NULL;

	if (dets != NULL)
	{
	  cvReleaseMat(&dets);
		dets = NULL;
	}
	if (boxes != NULL)
	{
	  cvReleaseMat(&boxes);
		boxes = NULL;
	}
	if (info != NULL)
	{
	  cvReleaseMatND(&info);
		info = NULL;
	}

  return thresh;   
}
예제 #24
0
//------------------------------------------------------------------------------
// Color Similarity Matrix Calculation
//------------------------------------------------------------------------------
CvMat *colorsim(int nbins, double sigma) {

	CvMat *xc=cvCreateMat(1,nbins, CV_32FC1);
	CvMat *yr=cvCreateMat(nbins,1, CV_32FC1);

	CvMat *x=cvCreateMat(nbins,nbins, CV_32FC1);
	CvMat *y=cvCreateMat(nbins,nbins, CV_32FC1);
	CvMat *m=cvCreateMat(x->rows,x->rows, CV_32FC1);


	// Set x,y directions 
	for (int j=0;j<nbins;j++) {
		cvSetReal2D(xc,0,j,(j+1-0.5)/nbins);
		cvSetReal2D(yr,j,0,(j+1-0.5)/nbins);
	}

	// Set u,v, meshgrids
	for (int i=0;i<x->rows;i++) {
		cvRepeat(xc,x);
		cvRepeat(yr,y);
	}

	CvMat *sub = cvCreateMat(x->rows,y->cols,CV_32FC1);
	cvSub(x,y,sub);
	cvAbs(sub,sub);
	cvMul(sub,sub,sub);
	cvConvertScale(sub,sub,-1.0/(2*sigma*sigma));
	cvExp(sub,sub);
	cvSubRS(sub,cvScalar(1.0),m);

	cvReleaseMat(&xc);
	cvReleaseMat(&yr);
	cvReleaseMat(&x);
	cvReleaseMat(&y);
	cvReleaseMat(&sub);

	return m;
}
예제 #25
0
static void dance_dynamics(const CvMat* x_k,
                           const CvMat* u_k,
                           const CvMat* v_k,
                           CvMat* x_kplus1)
{
    /* Assuming that the time-step is one frame rather than e.g.
     * 33 msec - I take the actual time step into account in
     * analysis. */
    double dT = 1.0;

    /* cvGetReal2D is useful to get an element of a 2D matrix
     * cvGetReal2D(x_k, i, j) gets the (i,k)^th element
     * Note that x_k is a 4x1 matrix here */
    double x = cvGetReal2D(x_k, 0, 0);
    double y = cvGetReal2D(x_k, 1, 0);
    double vx = cvGetReal2D(x_k, 2, 0); /* heading [rad] */
    double vy = cvGetReal2D(x_k, 3, 0); /* speed */

    /* position(t + 1) = position(t) + dT*velocity */
    x += dT*vx;
    y += dT*vy;

    /* works just like cvGetReal2D */
    cvSetReal2D(x_kplus1, 0, 0, x);
    cvSetReal2D(x_kplus1, 1, 0, y);
    cvSetReal2D(x_kplus1, 2, 0, vx);
    cvSetReal2D(x_kplus1, 3, 0, vy);

    /* this allows v_k to be a NULL pointer, in which case
     * this step is skipped */
    if(v_k)
    {
        /* simple additive noise: x(t+1) <- x(t+1) + noise */
        cvAdd(x_kplus1, v_k, x_kplus1);
    }
    
}
예제 #26
0
/* Using this function below to constrain the state estimate.  The
 * constraint is applied after the UKF correction step.
 *
 * Constraints applied:
 *   0 <= x <= frame (image) width
 *   0 <= y <= frame height
 *   0 <= speed <= 100 (px/frame)
 *   If x, y, heading, or speed are NaN, then
 *      a) if the corresponding estimate is valid, that number is used
 *      b) if the estimate is also NaN, x, y, and heading are set to
 *          0, speed is set to 0.1 
 */
void constrain_state(CvMat* x_k,
                     CvMat* X_p,
                     double tank_radius,
                     double water_depth)
{
    double x     = cvGetReal2D(x_k, BELUGA_STATE_X, 0);
    double y     = cvGetReal2D(x_k, BELUGA_STATE_Y, 0);
    double z     = cvGetReal2D(x_k, BELUGA_STATE_Z, 0);
    double zdot  = cvGetReal2D(x_k, BELUGA_STATE_ZDOT, 0);
    double speed = cvGetReal2D(x_k, BELUGA_STATE_SPEED, 0);
    double theta = cvGetReal2D(x_k, BELUGA_STATE_THETA, 0);
    double omega = cvGetReal2D(x_k, BELUGA_STATE_OMEGA, 0);    

    double x_p     = cvGetReal2D(X_p, BELUGA_STATE_X, 0);
	double y_p	   = cvGetReal2D(X_p, BELUGA_STATE_Y, 0);
	double z_p	   = cvGetReal2D(X_p, BELUGA_STATE_Z, 0);
	double zdot_p  = cvGetReal2D(X_p, BELUGA_STATE_ZDOT, 0);
	double speed_p = cvGetReal2D(X_p, BELUGA_STATE_SPEED, 0);
	double theta_p = cvGetReal2D(X_p, BELUGA_STATE_THETA, 0);
	double omega_p = cvGetReal2D(X_p, BELUGA_STATE_OMEGA, 0);	 

    x = check_nan(x, x_p, 0);
    y = check_nan(y, y_p, 0);
    z = check_nan(z, z_p, water_depth);
    zdot = check_nan(zdot, zdot_p, 0);
    speed = check_nan(speed, speed_p, 0.1);
    theta = check_nan(theta, theta_p, 0);
    omega = check_nan(omega, omega_p, 0);

	if(x*x + y*y > tank_radius)
	{
		double phi = atan2(y, x);
		x = 0.95*tank_radius*cos(phi);
		y = 0.95*tank_radius*sin(phi);
	}

    z = MT_CLAMP(z, 0, water_depth);
    zdot = MT_CLAMP(zdot, -BELUGA_CONSTRAINT_MAX_VERTICAL_SPEED,
                    BELUGA_CONSTRAINT_MAX_VERTICAL_SPEED);
    speed = MT_CLAMP(speed, 0, BELUGA_CONSTRAINT_MAX_SPEED);
    omega = MT_CLAMP(omega, -BELUGA_CONSTRAINT_MAX_TURN_RATE,
                     BELUGA_CONSTRAINT_MAX_TURN_RATE);
    
    cvSetReal2D(x_k, BELUGA_STATE_X, 0, x);		 
	cvSetReal2D(x_k, BELUGA_STATE_Y, 0, y);		 
	cvSetReal2D(x_k, BELUGA_STATE_Z, 0, z);		 
	cvSetReal2D(x_k, BELUGA_STATE_ZDOT, 0, zdot);		 
	cvSetReal2D(x_k, BELUGA_STATE_SPEED, 0, speed);	 
	cvSetReal2D(x_k, BELUGA_STATE_THETA, 0, theta);	 
	cvSetReal2D(x_k, BELUGA_STATE_OMEGA, 0, omega);	 
                
}
예제 #27
0
void FrequencyFilter::ChangePosition(IplImage *pImage)
{
    int x, y;
    float fValue;

    for(y = 0; y < pImage->height; y++)
        for(x = 0; x < pImage->width; x++)
        {
            fValue = (float)cvGetReal2D(pImage, y, x);
            if((x+y)%2 == 1)
                fValue = - fValue;
            cvSetReal2D(pImage, y, x, fValue);
        }

}
예제 #28
0
void DblMatrix::SaveAsBMP(std::string Name)
{
	double Min=DBL_MAX, Max=-DBL_MAX;
	MinMax(Min, Max);
	IplImage* Output = cvCreateImage(cvSize(GetWidth(), GetHeight()), IPL_DEPTH_8U, 1); 
	for(int j=0; j<GetHeight(); j++)
		for(int i=0; i<GetWidth(); i++)
		{
			double u = (*this)[j][i];
			double v = 255.0 * (u-Min)/(Max-Min);
			cvSetReal2D(Output, j, i, v);
		}
	cvSaveImage(Name.c_str(), Output);
	cvReleaseImage(&Output);
}
void CTWithWater::setCalibrationAndWaterDepth(const CalibrationData& calibrationData,
                                               double water_depth)
{
    calibrationDataToOpenCVCalibration(calibrationData,
                                       m_CameraMatrix,
                                       m_DistCoeffs,
                                       m_Rv,
                                       m_T,
                                       m_R);

    /* CameraWorld = -R^T T */
    cvGEMM(m_R, m_T, -1.0, NULL, 0, m_CameraWorld, CV_GEMM_A_T);


    cvSetIdentity(m_CameraMatrixNorm);
    /* TODO: These should really be read in from the calibration */
    cvSetReal2D(m_CameraMatrixNorm, 0, 0, 472.0);
    cvSetReal2D(m_CameraMatrixNorm, 1, 1, 472.0);
    cvSetReal2D(m_CameraMatrixNorm, 0, 2, 320.0);
    cvSetReal2D(m_CameraMatrixNorm, 1, 2, 240.0);
    cvZero(m_DistCoeffsNorm);

    setWaterDepth(water_depth);
}
예제 #30
0
// This function actually applies the specified noise to the given image
// in the given amounts
IplImage* GenerateNoise(IplImage* img, int noiseType, float amount=255)
{
	CvSize imgSize = cvGetSize(img);
	IplImage* imgTemp = cvCloneImage(img);	// This will hold the noisy image

	// Go through each pixel
	for(int y=0;y<imgSize.height;y++)
	{
		for(int x=0;x<imgSize.width;x++)
		{
			int randomValue=0;				// Our noise is additive.. this holds
			switch(noiseType)				// the amount to add/subtract
			{
			case NOISE_UNIFORM:				// I chose UNIFORM, so give me a uniform random number
				randomValue = (char)(uniform()*amount);
				break;

			case NOISE_EXPONENTIAL:			// I chose EXPONENTIAL... so exp random number please
				randomValue = (int)(exponential()*amount);
				break;

			case NOISE_GAUSSIAN:			// same here
				randomValue = (int)(gaussian()*amount);
				break;

			case NOISE_RAYLEIGH:			// ... guess!!
				randomValue = (int)(rayleigh()*amount);
				break;

			case NOISE_GAMMA:				// I chose gamma... give me a gamma random number
				randomValue = (int)(gamma()*amount);
				break;

			case NOISE_IMPULSE:				// I need salt and pepper.. pass the shakers please
				randomValue = (int)(impulse((float)amount/256)*amount);
			}
			
			// Here we "apply" the noise to the current pixel
			int pixelValue = cvGetReal2D(imgTemp, y, x)+randomValue;

			// And set this value in our noisy image
			cvSetReal2D(imgTemp, y, x, pixelValue);
		}
	}

	// return
	return imgTemp;
}