Example Convolution - Revision history

Peter at 22:59, 17 January 2022

2022-01-17T22:59:29Z

← Older revision		Revision as of 22:59, 17 January 2022
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.39/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.40/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 24:		Line 24:

	public static void main( String[] args ) {		public static void main( String[] args ) {
	BufferedImage image = UtilImageIO.~~loadImage~~(UtilIO.pathExample("sunflowers.jpg"));		BufferedImage image = UtilImageIO.loadImageNotNull(UtilIO.pathExample("sunflowers.jpg"));

	GrayU8 gray = ConvertBufferedImage.convertFromSingle(image, null, GrayU8.class);		GrayU8 gray = ConvertBufferedImage.convertFromSingle(image, null, GrayU8.class);

Peter at 03:18, 9 October 2021

2021-10-09T03:18:02Z

← Older revision		Revision as of 03:18, 9 October 2021
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.39/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 39:		Line 39:
	*/		*/
	private static void convolve1D( GrayU8 gray ) {		private static void convolve1D( GrayU8 gray ) {
	~~ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);~~		var kernel = new Kernel1D_S32(2);
	~~Kernel1D_S32~~ kernel = new Kernel1D_S32(2);
	kernel.offset = 1; // specify the kernel's origin		kernel.offset = 1; // specify the kernel's origin
	kernel.data[0] = 1;		kernel.data[0] = 1;
	kernel.data[1] = -1;		kernel.data[1] = -1;

	~~GrayS16~~ output = new GrayS16(gray.width, gray.height);		var output = new GrayS16(gray.width, gray.height);

	GConvolveImageOps.horizontal(kernel, gray, output, ~~border~~);		GConvolveImageOps.horizontal(kernel, gray, output, BorderType.EXTENDED);
	panel.addImage(VisualizeImageData.standard(output, null), "1D Horizontal");		panel.addImage(VisualizeImageData.standard(output, null), "1D Horizontal");

	GConvolveImageOps.vertical(kernel, gray, output, ~~border~~);		GConvolveImageOps.vertical(kernel, gray, output, BorderType.EXTENDED);
	panel.addImage(VisualizeImageData.standard(output, null), "1D Vertical");		panel.addImage(VisualizeImageData.standard(output, null), "1D Vertical");
	}		}
Line 59:		Line 58:
	private static void convolve2D( GrayU8 gray ) {		private static void convolve2D( GrayU8 gray ) {
	// By default 2D kernels will be centered around width/2		// By default 2D kernels will be centered around width/2
	~~Kernel2D_S32~~ kernel = new Kernel2D_S32(3);		var kernel = new Kernel2D_S32(3);
	kernel.set(1, 0, 2);		kernel.set(1, 0, 2);
	kernel.set(2, 1, 2);		kernel.set(2, 1, 2);
Line 66:		Line 65:

	// Output needs to handle the increased domain after convolution. Can't be 8bit		// Output needs to handle the increased domain after convolution. Can't be 8bit
	~~GrayS16~~ output = new GrayS16(gray.width, gray.height);		var output = new GrayS16(gray.width, gray.height);
	~~ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray~~);

	GConvolveImageOps.convolve(kernel, gray, output, ~~border~~);		GConvolveImageOps.convolve(kernel, gray, output, BorderType.EXTENDED);
	panel.addImage(VisualizeImageData.standard(output, null), "2D Kernel");		panel.addImage(VisualizeImageData.standard(output, null), "2D Kernel");
	}		}
Line 83:		Line 81:

	// Since it's normalized it can be saved inside an 8bit image		// Since it's normalized it can be saved inside an 8bit image
	~~GrayU8~~ output = new GrayU8(gray.width, gray.height);		var output = new GrayU8(gray.width, gray.height);

	GConvolveImageOps.convolveNormalized(kernel, gray, output);		GConvolveImageOps.convolveNormalized(kernel, gray, output);

Peter at 18:54, 12 July 2021

2021-07-12T18:54:27Z

← Older revision		Revision as of 18:54, 12 July 2021
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.38/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 21:		Line 21:
	public class ExampleConvolution {		public class ExampleConvolution {

	private static ListDisplayPanel panel = new ListDisplayPanel();		private static final ListDisplayPanel panel = new ListDisplayPanel();

	public static void main(String[] args) {		public static void main( String[] args ) {
	BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));		BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));

Line 32:		Line 32:
	normalize2D(gray);		normalize2D(gray);

	ShowImages.showWindow(panel,"Convolution Examples",true);		ShowImages.showWindow(panel, "Convolution Examples", true);
	}		}

Line 38:		Line 38:
	* Convolves a 1D kernel horizontally and vertically		* Convolves a 1D kernel horizontally and vertically
	*/		*/
	private static void convolve1D(GrayU8 gray) {		private static void convolve1D( GrayU8 gray ) {
	ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);		ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);
	Kernel1D_S32 kernel = new Kernel1D_S32(2);		Kernel1D_S32 kernel = new Kernel1D_S32(2);
Line 45:		Line 45:
	kernel.data[1] = -1;		kernel.data[1] = -1;

	GrayS16 output = new GrayS16(gray.width,gray.height);		GrayS16 output = new GrayS16(gray.width, gray.height);

	GConvolveImageOps.horizontal(kernel, gray, output, border);		GConvolveImageOps.horizontal(kernel, gray, output, border);
Line 57:		Line 57:
	* Convolves a 2D kernel		* Convolves a 2D kernel
	*/		*/
	private static void convolve2D(GrayU8 gray) {		private static void convolve2D( GrayU8 gray ) {
	// By default 2D kernels will be centered around width/2		// By default 2D kernels will be centered around width/2
	Kernel2D_S32 kernel = new Kernel2D_S32(3);		Kernel2D_S32 kernel = new Kernel2D_S32(3);
	kernel.set(1,0,2);		kernel.set(1, 0, 2);
	kernel.set(2,1,2);		kernel.set(2, 1, 2);
	kernel.set(0,1,-2);		kernel.set(0, 1, -2);
	kernel.set(1,2,-2);		kernel.set(1, 2, -2);

	// Output needs to handle the increased domain after convolution. Can't be 8bit		// Output needs to handle the increased domain after convolution. Can't be 8bit
	GrayS16 output = new GrayS16(gray.width,gray.height);		GrayS16 output = new GrayS16(gray.width, gray.height);
	ImageBorder<GrayU8> border = FactoryImageBorder.wrap( BorderType.EXTENDED,gray);		ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);

	GConvolveImageOps.convolve(kernel, gray, output, border);		GConvolveImageOps.convolve(kernel, gray, output, border);
Line 74:		Line 74:

	/**		/**
	* Convolves a 2D normalized kernel. This kernel is divided by its sum after computation.		* Convolves a 2D normalized kernel. This kernel is divided by its sum after computation.
	*/		*/
	private static void normalize2D(GrayU8 gray) {		private static void normalize2D( GrayU8 gray ) {
	// Create a Gaussian kernel with radius of 3		// Create a Gaussian kernel with radius of 3
	Kernel2D_S32 kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);		Kernel2D_S32 kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);
Line 83:		Line 83:

	// Since it's normalized it can be saved inside an 8bit image		// Since it's normalized it can be saved inside an 8bit image
	GrayU8 output = new GrayU8(gray.width,gray.height);		GrayU8 output = new GrayU8(gray.width, gray.height);

	GConvolveImageOps.convolveNormalized(kernel, gray, output);		GConvolveImageOps.convolveNormalized(kernel, gray, output);

Peter at 02:15, 22 December 2020

2020-12-22T02:15:21Z

← Older revision		Revision as of 02:15, 22 December 2020
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.37/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:

Peter at 14:07, 15 March 2019

2019-03-15T14:07:00Z

← Older revision		Revision as of 14:07, 15 March 2019
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.33/examples/src/main/java/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:

Peter at 15:55, 17 August 2017

2017-08-17T15:55:29Z

← Older revision		Revision as of 15:55, 17 August 2017
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.27/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 39:		Line 39:
	*/		*/
	private static void convolve1D(GrayU8 gray) {		private static void convolve1D(GrayU8 gray) {
	ImageBorder<GrayU8> border = FactoryImageBorder.~~single~~(~~gray,~~ BorderType.EXTENDED);		ImageBorder<GrayU8> border = FactoryImageBorder.wrap(BorderType.EXTENDED, gray);
	~~Kernel1D_I32~~ kernel = new ~~Kernel1D_I32~~(2);		Kernel1D_S32 kernel = new Kernel1D_S32(2);
	kernel.offset = 1; // specify the kernel's origin		kernel.offset = 1; // specify the kernel's origin
	kernel.data[0] = 1;		kernel.data[0] = 1;
Line 59:		Line 59:
	private static void convolve2D(GrayU8 gray) {		private static void convolve2D(GrayU8 gray) {
	// By default 2D kernels will be centered around width/2		// By default 2D kernels will be centered around width/2
	~~Kernel2D_I32~~ kernel = new ~~Kernel2D_I32~~(3);		Kernel2D_S32 kernel = new Kernel2D_S32(3);
	kernel.set(1,0,2);		kernel.set(1,0,2);
	kernel.set(2,1,2);		kernel.set(2,1,2);
Line 67:		Line 67:
	// Output needs to handle the increased domain after convolution. Can't be 8bit		// Output needs to handle the increased domain after convolution. Can't be 8bit
	GrayS16 output = new GrayS16(gray.width,gray.height);		GrayS16 output = new GrayS16(gray.width,gray.height);
	ImageBorder<GrayU8> border = FactoryImageBorder.~~single~~(~~gray,~~ BorderType.EXTENDED);		ImageBorder<GrayU8> border = FactoryImageBorder.wrap( BorderType.EXTENDED,gray);

	GConvolveImageOps.convolve(kernel, gray, output, border);		GConvolveImageOps.convolve(kernel, gray, output, border);
Line 78:		Line 78:
	private static void normalize2D(GrayU8 gray) {		private static void normalize2D(GrayU8 gray) {
	// Create a Gaussian kernel with radius of 3		// Create a Gaussian kernel with radius of 3
	~~Kernel2D_I32~~ kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);		Kernel2D_S32 kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);
	// Note that there is a more efficient way to compute this convolution since it is a separable kernel		// Note that there is a more efficient way to compute this convolution since it is a separable kernel
	// just use BlurImageOps instead.		// just use BlurImageOps instead.

Peter at 03:26, 8 December 2016

2016-12-08T03:26:06Z

← Older revision		Revision as of 03:26, 8 December 2016
Line 7:		Line 7:
	* Convolution		* Convolution
	* Spacial filtering		* Spacial filtering

			Relevant Examples:
			* [[Example_Image_Blur\|Image Blur]]

	= Example Code =		= Example Code =

Peter at 04:44, 28 March 2016

2016-03-28T04:44:17Z

← Older revision		Revision as of 04:44, 28 March 2016
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.20/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.23/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 17:		Line 17:
	*/		*/
	public class ExampleConvolution {		public class ExampleConvolution {

			private static ListDisplayPanel panel = new ListDisplayPanel();

	public static void main(String[] args) {		public static void main(String[] args) {
	BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));		BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));

	~~ImageUInt8~~ gray = ConvertBufferedImage.convertFromSingle(image, null, ~~ImageUInt8~~.class);		GrayU8 gray = ConvertBufferedImage.convertFromSingle(image, null, GrayU8.class);

	convolve1D(gray);		convolve1D(gray);
	convolve2D(gray);		convolve2D(gray);
	normalize2D(gray);		normalize2D(gray);

			ShowImages.showWindow(panel,"Convolution Examples",true);
	}		}

Line 31:		Line 35:
	* Convolves a 1D kernel horizontally and vertically		* Convolves a 1D kernel horizontally and vertically
	*/		*/
	private static void convolve1D(~~ImageUInt8~~ gray) {		private static void convolve1D(GrayU8 gray) {
	ImageBorder<~~ImageUInt8~~> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);		ImageBorder<GrayU8> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);
	Kernel1D_I32 kernel = new Kernel1D_I32(2);		Kernel1D_I32 kernel = new Kernel1D_I32(2);
	kernel.offset = 1; // specify the kernel's origin		kernel.offset = 1; // specify the kernel's origin
Line 38:		Line 42:
	kernel.data[1] = -1;		kernel.data[1] = -1;

	~~ImageSInt16~~ output = new ~~ImageSInt16~~(gray.width,gray.height);		GrayS16 output = new GrayS16(gray.width,gray.height);

	GConvolveImageOps.horizontal(kernel, gray, output, border);		GConvolveImageOps.horizontal(kernel, gray, output, border);
	~~ShowImages~~.~~showWindow~~(VisualizeImageData.standard(output, null), "1D Horizontal");		panel.addImage(VisualizeImageData.standard(output, null), "1D Horizontal");

	GConvolveImageOps.vertical(kernel, gray, output, border);		GConvolveImageOps.vertical(kernel, gray, output, border);
	~~ShowImages~~.~~showWindow~~(VisualizeImageData.standard(output, null), "1D Vertical");		panel.addImage(VisualizeImageData.standard(output, null), "1D Vertical");
	}		}

Line 50:		Line 54:
	* Convolves a 2D kernel		* Convolves a 2D kernel
	*/		*/
	private static void convolve2D(~~ImageUInt8~~ gray) {		private static void convolve2D(GrayU8 gray) {
	// By default 2D kernels will be centered around width/2		// By default 2D kernels will be centered around width/2
	Kernel2D_I32 kernel = new Kernel2D_I32(3);		Kernel2D_I32 kernel = new Kernel2D_I32(3);
Line 59:		Line 63:

	// Output needs to handle the increased domain after convolution. Can't be 8bit		// Output needs to handle the increased domain after convolution. Can't be 8bit
	~~ImageSInt16~~ output = new ~~ImageSInt16~~(gray.width,gray.height);		GrayS16 output = new GrayS16(gray.width,gray.height);
	ImageBorder<~~ImageUInt8~~> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);		ImageBorder<GrayU8> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);

	GConvolveImageOps.convolve(kernel, gray, output, border);		GConvolveImageOps.convolve(kernel, gray, output, border);
	~~ShowImages~~.~~showWindow~~(VisualizeImageData.standard(output, null), "2D Kernel");		panel.addImage(VisualizeImageData.standard(output, null), "2D Kernel");
	}		}

Line 69:		Line 73:
	* Convolves a 2D normalized kernel. This kernel is divided by its sum after computation.		* Convolves a 2D normalized kernel. This kernel is divided by its sum after computation.
	*/		*/
	private static void normalize2D(~~ImageUInt8~~ gray) {		private static void normalize2D(GrayU8 gray) {
	// Create a Gaussian kernel with radius of 3		// Create a Gaussian kernel with radius of 3
	Kernel2D_I32 kernel = FactoryKernelGaussian.gaussian2D(~~ImageUInt8~~.class, -1, 3);		Kernel2D_I32 kernel = FactoryKernelGaussian.gaussian2D(GrayU8.class, -1, 3);
	// Note that there is a more efficient way to compute this convolution since it is a separable kernel		// Note that there is a more efficient way to compute this convolution since it is a separable kernel
	// just use BlurImageOps instead.		// just use BlurImageOps instead.

	// Since it's normalized it can be saved inside an 8bit image		// Since it's normalized it can be saved inside an 8bit image
	~~ImageUInt8~~ output = new ~~ImageUInt8~~(gray.width,gray.height);		GrayU8 output = new GrayU8(gray.width,gray.height);

	GConvolveImageOps.convolveNormalized(kernel, gray, output);		GConvolveImageOps.convolveNormalized(kernel, gray, output);
	~~ShowImages~~.~~showWindow~~(VisualizeImageData.standard(output, null), "2D Normalized Kernel");		panel.addImage(VisualizeImageData.standard(output, null), "2D Normalized Kernel");
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

Peter at 15:13, 9 November 2015

2015-11-09T15:13:29Z

← Older revision		Revision as of 15:13, 9 November 2015
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.19/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.20/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 19:		Line 19:

	public static void main(String[] args) {		public static void main(String[] args) {
	BufferedImage image = UtilImageIO.loadImage("~~../data/applet/~~sunflowers.jpg");		BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));

	ImageUInt8 gray = ConvertBufferedImage.convertFromSingle(image, null, ImageUInt8.class);		ImageUInt8 gray = ConvertBufferedImage.convertFromSingle(image, null, ImageUInt8.class);

Peter at 19:33, 19 September 2015

2015-09-19T19:33:47Z

← Older revision		Revision as of 19:33, 19 September 2015
Line 2:		Line 2:

	Example Code:		Example Code:
	* [https://github.com/lessthanoptimal/BoofCV/blob/v0.18/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]		* [https://github.com/lessthanoptimal/BoofCV/blob/v0.19/examples/src/boofcv/examples/imageprocessing/ExampleConvolution.java ExampleConvolution.java]

	Concepts:		Concepts:
Line 32:		Line 32:
	*/		*/
	private static void convolve1D(ImageUInt8 gray) {		private static void convolve1D(ImageUInt8 gray) {
	ImageBorder<ImageUInt8> border = FactoryImageBorder.~~general~~(gray, BorderType.EXTENDED);		ImageBorder<ImageUInt8> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);
	Kernel1D_I32 kernel = new Kernel1D_I32(2);		Kernel1D_I32 kernel = new Kernel1D_I32(2);
	kernel.offset = 1; // specify the kernel's origin		kernel.offset = 1; // specify the kernel's origin
Line 60:		Line 60:
	// Output needs to handle the increased domain after convolution. Can't be 8bit		// Output needs to handle the increased domain after convolution. Can't be 8bit
	ImageSInt16 output = new ImageSInt16(gray.width,gray.height);		ImageSInt16 output = new ImageSInt16(gray.width,gray.height);
	ImageBorder<ImageUInt8> border = FactoryImageBorder.~~general~~(gray, BorderType.EXTENDED);		ImageBorder<ImageUInt8> border = FactoryImageBorder.single(gray, BorderType.EXTENDED);

	GConvolveImageOps.convolve(kernel, gray, output, border);		GConvolveImageOps.convolve(kernel, gray, output, border);