Java ImageFloat32.set方法代码示例

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes the disparity for two stereo images along the image's right axis.  Both
 * image must be rectified.
 *
 * @param left Left camera image.
 * @param right Right camera image.
 */
public void process( I left , I right , ImageFloat32 imageDisparity ) {
	// check inputs and initialize data structures
	InputSanityCheck.checkSameShape(left,right,imageDisparity);
	this.imageLeft = left;
	this.imageRight = right;

	w = left.width; h = left.height;

	// Compute disparity for each pixel
	for( int y = radiusY*2; y < h-radiusY*2; y++ ) {
		for( int x = radiusX*2+minDisparity; x < w-radiusX*2; x++ ) {
			// take in account image border when computing max disparity
			int max = x-Math.max(radiusX*2-1,x-score.length);

			// compute match score across all candidates
			processPixel(x, y, max);

			// select the best disparity
			imageDisparity.set(x,y,(float)selectBest(max));
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes the disparity for two stereo images along the image's right axis.  Both
 * image must be rectified.
 *
 * @param left Left camera image.
 * @param right Right camera image.
 */
public void process( I left , I right , ImageFloat32 imageDisparity ) {
	// check inputs and initialize data structures
	InputSanityCheck.checkSameShape(left,right,imageDisparity);
	this.imageLeft = left;
	this.imageRight = right;

	w = left.width; h = left.height;

	// Compute disparity for each pixel
	for( int y = radiusY; y < h-radiusY; y++ ) {
		for( int x = radiusX+minDisparity; x < w-radiusX; x++ ) {
			// take in account image border when computing max disparity
			int max = x-Math.max(radiusX-1,x-score.length);

			// compute match score across all candidates
			processPixel( x , y , max );

			// select the best disparity
			imageDisparity.set(x,y,(float)selectBest(max));
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
@Test
public void discretizeDirection4() {
	ImageFloat32 angle = new ImageFloat32(5,5);
	angle.set(0,0,(float)(3*Math.PI/8+0.01));
	angle.set(1,0,(float)(3*Math.PI/8-0.01));
	angle.set(2,0,(float)(Math.PI/4));
	angle.set(3,0,(float)(Math.PI/8+0.01));
	angle.set(4,0,(float)(Math.PI/8-0.01));
	angle.set(0,1,(float)(-3*Math.PI/8+0.01));
	angle.set(1,1,(float)(-3*Math.PI/8-0.01));

	ImageSInt8 d = new ImageSInt8(5,5);

	GradientToEdgeFeatures.discretizeDirection4(angle,d);

	assertEquals(2,d.get(0,0));
	assertEquals(1,d.get(1,0));
	assertEquals(1,d.get(2,0));
	assertEquals(1,d.get(3,0));
	assertEquals(0,d.get(4,0));
	assertEquals(-1,d.get(0,1));
	assertEquals(2,d.get(1,1));
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
@Test
public void naive4() {
	ImageFloat32 intensity = new ImageFloat32(3,3);
	ImageFloat32 output = new ImageFloat32(3,3);
	ImageSInt8 direction = new ImageSInt8(3,3);

	// test it against simple positive and negative cases
	for( int dir = -1; dir < 3; dir++ ) {
		direction.set(1,1,dir);

		GImageMiscOps.fill(intensity, 0);
		intensity.set(1,1,10);

		// test suppress
		setByDirection4(intensity,dir,15);
		ImplEdgeNonMaxSuppression.naive4(intensity,direction,output);

		assertEquals(0,output.get(1,1),1e-4f);

		// test no suppression
		setByDirection4(intensity,dir,5);
		ImplEdgeNonMaxSuppression.naive4(intensity,direction,output);

		assertEquals(intensity.get(1,1),output.get(1,1),1e-4f);
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
@Test
public void naive8() {
	ImageFloat32 intensity = new ImageFloat32(3,3);
	ImageFloat32 output = new ImageFloat32(3,3);
	ImageSInt8 direction = new ImageSInt8(3,3);

	// test it against simple positive and negative cases
	for( int dir = -3; dir < 5; dir++ ) {
		direction.set(1,1,dir);

		GImageMiscOps.fill(intensity,0);
		intensity.set(1,1,10);

		// test suppress
		setByDirection8(intensity,dir,15);
		ImplEdgeNonMaxSuppression.naive8(intensity,direction,output);

		assertEquals(0,output.get(1,1),1e-4f);

		// test no suppression
		setByDirection8(intensity,dir,5);
		ImplEdgeNonMaxSuppression.naive8(intensity,direction,output);

		assertEquals(intensity.get(1,1),output.get(1,1),1e-4f);
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * The size of N is less than the number of points
 */
@Test
public void testTooLittle() {

	ImageFloat32 intensity = new ImageFloat32(10,20);
	intensity.set(5,10,-3);
	intensity.set(4,10,-3.5f);
	intensity.set(5,11,0);
	intensity.set(8,8,10);

	QueueCorner corners = new QueueCorner();
	corners.add(5,10);
	corners.add(4,10);
	corners.add(5,11);
	corners.add(8,8);

	SelectNBestFeatures alg = new SelectNBestFeatures(20);
	alg.setN(20);
	alg.process(intensity,corners,true);

	QueueCorner found = alg.getBestCorners();

	assertEquals(4,found.size);
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Computes the derivative of 'orig' along the x and y axes
 */
public static void process( ImageFloat32 orig,
							ImageFloat32 derivX,
							ImageFloat32 derivY) {
	final int width = orig.getWidth();
	final int height = orig.getHeight();

	for (int y = 1; y < height - 1; y++) {

		for (int x = 1; x < width - 1; x++) {

			float dy = -(orig.get(x - 1, y - 1) * 0.25F + orig.get(x, y - 1) * 0.5F + orig.get(x + 1, y - 1) * 0.25F);
			dy += (orig.get(x - 1, y + 1) * 0.25F + orig.get(x, y + 1) * 0.5F + orig.get(x + 1, y + 1) * 0.25F);


			float dx = -(orig.get(x - 1, y - 1) * 0.25F + orig.get(x - 1, y) * 0.5F + orig.get(x - 1, y + 1) * 0.25F);
			dx += (orig.get(x + 1, y - 1) * 0.25F + orig.get(x + 1, y) * 0.5F + orig.get(x + 1, y + 1) * 0.25F);

			derivX.set(x, y, dx);
			derivY.set(x, y, dy);
		}
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
@Test
public void add_F32() {
	ImageFloat32 img = new ImageFloat32(2,3);
	
	img.set(0,0,1);
	img.set(1,2,3);

	BoofTesting.checkSubImage(this,"add_F32",false,img);
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
private static void computeHessian(ImageFloat32 integral, ImageFloat32 intensity, IntegralKernel kerXX, IntegralKernel kerYY, IntegralKernel kerXY, float norm, int y, int yy, int x, int xx) {
	float Dxx = IntegralImageOps.convolveSparse(integral,kerXX,xx,yy);
	float Dyy = IntegralImageOps.convolveSparse(integral,kerYY,xx,yy);
	float Dxy = IntegralImageOps.convolveSparse(integral,kerXY,xx,yy);

	Dxx *= norm;
	Dxy *= norm;
	Dyy *= norm;

	float det = Dxx*Dyy-0.81f*Dxy*Dxy;

	intensity.set(x,y,det);
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Slow algorithm which processes the whole image.
 */
static public void naive4( ImageFloat32 _intensity , ImageSInt8 direction , ImageFloat32 output )
{
	final int w = _intensity.width;
	final int h = _intensity.height;

	ImageBorder_F32 intensity = (ImageBorder_F32)FactoryImageBorderAlgs.value(_intensity, 0);

	for( int y = 0; y < h; y++ ) {
		for( int x = 0; x < w; x++ ) {
			int dir = direction.get(x,y);
			int dx,dy;

			if( dir == 0 ) {
				dx = 1; dy = 0;
			} else if( dir == 1 ) {
				dx = 1; dy = 1;
			} else if( dir == 2 ) {
				dx = 0; dy = 1;
			} else {
				dx = 1; dy = -1;
			}

			float left = intensity.get(x-dx,y-dy);
			float middle = intensity.get(x,y);
			float right = intensity.get(x+dx,y+dy);

			// suppress the value if either of its neighboring values are more than or equal to it
			if( left > middle || right > middle ) {
				output.set(x,y,0);
			} else {
				output.set(x,y,middle);
			}
		}
	}

}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * Slow algorithm which processes the whole image.
 */
static public void naive8( ImageFloat32 _intensity , ImageSInt8 direction , ImageFloat32 output )
{
	final int w = _intensity.width;
	final int h = _intensity.height;

	ImageBorder_F32 intensity = (ImageBorder_F32)FactoryImageBorderAlgs.value(_intensity, 0);

	for( int y = 0; y < h; y++ ) {
		for( int x = 0; x < w; x++ ) {
			int dir = direction.get(x,y);
			int dx,dy;

			if( dir == 0 || dir == 4) {
				dx = 1; dy = 0;
			} else if( dir == 1 || dir == -3) {
				dx = 1; dy = 1;
			} else if( dir == 2 || dir == -2) {
				dx = 0; dy = 1;
			} else {
				dx = 1; dy = -1;
			}

			float left = intensity.get(x-dx,y-dy);
			float middle = intensity.get(x,y);
			float right = intensity.get(x+dx,y+dy);

			// suppress the value if either of its neighboring values are more than or equal to it
			if( left > middle || right > middle ) {
				output.set(x,y,0);
			} else {
				output.set(x,y,middle);
			}
		}
	}

}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
private void setByDirection4( ImageFloat32 img , int dir , float value ) {
	if( dir == 0 ) {
		img.set(0,1,value);
		img.set(2,1,value);
	} else if( dir == 1 ) {
		img.set(2,2,value);
		img.set(0,0,value);
	} else if( dir == 2 ) {
		img.set(1,0,value);
		img.set(1,2,value);
	} else {
		img.set(2,0,value);
		img.set(0,2,value);
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
private void setByDirection8( ImageFloat32 img , int dir , float value ) {
	if( dir == 0 || dir == 4) {
		img.set(0,1,value);
		img.set(2,1,value);
	} else if( dir == 1 || dir == -3) {
		img.set(2,2,value);
		img.set(0,0,value);
	} else if( dir == 2 || dir == -2) {
		img.set(1,0,value);
		img.set(1,2,value);
	} else {
		img.set(2,0,value);
		img.set(0,2,value);
	}
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
/**
 * The value of N is less than the number of features
 */
@Test
public void testExtra() {

	ImageFloat32 intensity = new ImageFloat32(10,20);
	intensity.set(5,10,-3);
	intensity.set(4,10,-3.5f);
	intensity.set(5,11,0);
	intensity.set(8,8,10);

	QueueCorner corners = new QueueCorner();
	corners.add(5,10);
	corners.add(4,10);
	corners.add(5,11);
	corners.add(8,8);

	SelectNBestFeatures alg = new SelectNBestFeatures(20);
	alg.setN(3);
	alg.process(intensity,corners,true);

	QueueCorner found = alg.getBestCorners();

	assertEquals(3,found.size);
	assertEquals(8,found.get(0).x);
	assertEquals(8,found.get(0).y);

	// same test, but with negative features
	alg.process(intensity,corners,false);

	found = alg.getBestCorners();

	assertEquals(3,found.size);
	assertEquals(4,found.get(0).x);
	assertEquals(10,found.get(0).y);
}
 

import boofcv.struct.image.ImageFloat32; //导入方法依赖的package包/类
private void drawCircle( ImageFloat32 img , int c_x , int c_y , double r ) {

		for( int y = 0; y < img.height; y++ ) {
			for( int x = 0; x < img.width; x++ ) {
				double d = UtilPoint2D_I32.distance(x,y,c_x,c_y);
				if( d <= r ) {
					img.set(x,y,0);
				}
			}
		}
	}