Tutorial Processing - Revision history

Peter at 01:59, 6 December 2016

2016-12-06T01:59:11Z

← Older revision		Revision as of 01:59, 6 December 2016
Line 8:		Line 8:
	The Processing wrapper for BoofCV (BoofProcessing) has been pushed into it's own project, see below. BoofProcessing supports Processing 3.x.		The Processing wrapper for BoofCV (BoofProcessing) has been pushed into it's own project, see below. BoofProcessing supports Processing 3.x.

	[https://github.com/lessthanoptimal/BoofProcessing BoofProcessing]		[https://github.com/lessthanoptimal/BoofProcessing BoofProcessing source code on GitHub]

	The latest stable version can be downloaded from GitHub, but it's easier to just install it with Processing.		The latest stable version can be downloaded from GitHub, but it's easier to just install it with Processing.

Peter at 17:08, 9 March 2016

2016-03-09T17:08:02Z

← Older revision		Revision as of 17:08, 9 March 2016
Line 6:		Line 6:

	== Installing ==		== Installing ==
	The Processing wrapper for BoofCV has been pushed into it's own project:		The Processing wrapper for BoofCV (BoofProcessing) has been pushed into it's own project, see below. BoofProcessing supports Processing 3.x.

	[https://github.com/lessthanoptimal/BoofProcessing BoofProcessing]		[https://github.com/lessthanoptimal/BoofProcessing BoofProcessing]

Peter at 17:07, 9 March 2016

2016-03-09T17:07:01Z

← Older revision		Revision as of 17:07, 9 March 2016
Line 6:		Line 6:

	== Installing ==		== Installing ==
	The ~~latest stable version of~~ BoofCV ~~can be easily installed~~ into ~~your Processing build environment. No compilation is required.~~		The Processing wrapper for BoofCV has been pushed into it's own project:

			[https://github.com/lessthanoptimal/BoofProcessing BoofProcessing]

			The latest stable version can be downloaded from GitHub, but it's easier to just install it with Processing.
	* Sketch -> Import Library -> Add Library ...		* Sketch -> Import Library -> Add Library ...
	* Type "boofcv" into filter		* Type "boofcv" into filter
	* Select and click Install button		* Select and click Install button
	* Wait for it to download and you're ready to go!		* Wait for it to download and you're ready to go!

	If you want the bleeding edge code from GitHub then you'll need to compile it yourself. By default Gradle will build the jar for Processing, provided you have set your system up correctly. Instructions are in boofcv/integration/processing/readme.txt, for your convenience it's pasted below:

	~~<blockquote>~~
	Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.

	~~Testing has been done using Processing 3.X and no longer works on 2.X~~

	~~-------~~

	~~To create the zip package for Processing type 'gradle processingZip' and after a little bit boofcv_processing.zip should appear in integration/processing directory.~~
	~~</blockquote>~~


	== API and Usage Examples ==		== API and Usage Examples ==

Peter at 17:04, 9 March 2016

2016-03-09T17:04:13Z

← Older revision		Revision as of 17:04, 9 March 2016
Line 18:		Line 18:
	Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.		Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.

	Testing has been done using Processing 2.X		Testing has been done using Processing 3.X and no longer works on 2.X

	-------		-------
Line 28:		Line 28:
	== API and Usage Examples ==		== API and Usage Examples ==
	Click below for a complete set of usage examples on GitHub:		Click below for a complete set of usage examples on GitHub:
	* [https://github.com/lessthanoptimal/~~BoofCV~~/tree/master~~/integration/processing~~/examples ~~boofcv/integration/processing~~/examples]		* [https://github.com/lessthanoptimal/BoofProcessing/tree/master/examples BoofProcessing/examples]

	Browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than general BoofCV API and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.		Browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than general BoofCV API and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.

	Consult the [https://github.com/lessthanoptimal/~~BoofCV~~/blob/master~~/integration/processing~~/README.~~TXT~~ README.~~TXT~~] for instructions on how to build Processing support using Gradle.		Consult the [https://github.com/lessthanoptimal/BoofProcessing/blob/master/README.MD README.MD] for instructions on how to build Processing support using Gradle.

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">
Line 58:		Line 58:
	imgBlobs = results.getLabeledImage().visualize();		imgBlobs = results.getLabeledImage().visualize();

	~~size~~(input.width, input.height);		surface.setSize(input.width, input.height);
	}		}

Peter at 12:13, 9 September 2014

2014-09-09T12:13:43Z

← Older revision		Revision as of 12:13, 9 September 2014
Line 13:		Line 13:
	* Wait for it to download and you're ready to go!		* Wait for it to download and you're ready to go!

	If you want the bleeding edge code from GitHub then you'll need to compile it yourself. By default Gradle will build the jar for Processing, provided you have set your system up correctly. Instructions are in boofcv/integration/processing/readme.txt, for your convenience ~~the import part is~~ pasted below:		If you want the bleeding edge code from GitHub then you'll need to compile it yourself. By default Gradle will build the jar for Processing, provided you have set your system up correctly. Instructions are in boofcv/integration/processing/readme.txt, for your convenience it's pasted below:

	<blockquote>		<blockquote>
	Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.		Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.

			Testing has been done using Processing 2.X

			-------

			To create the zip package for Processing type 'gradle processingZip' and after a little bit boofcv_processing.zip should appear in integration/processing directory.
	</blockquote>		</blockquote>

Peter at 12:05, 9 September 2014

2014-09-09T12:05:42Z

← Older revision		Revision as of 12:05, 9 September 2014
Line 5:		Line 5:
	</blockquote>		</blockquote>

	~~Usage examples~~ can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples ~~GitHub in the~~ examples ~~directory~~] ~~and browsing~~ through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than ~~most of~~ BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.		== Installing ==
			The latest stable version of BoofCV can be easily installed into your Processing build environment. No compilation is required.

			* Sketch -> Import Library -> Add Library ...
			* Type "boofcv" into filter
			* Select and click Install button
			* Wait for it to download and you're ready to go!

			If you want the bleeding edge code from GitHub then you'll need to compile it yourself. By default Gradle will build the jar for Processing, provided you have set your system up correctly. Instructions are in boofcv/integration/processing/readme.txt, for your convenience the import part is pasted below:

			<blockquote>
			Gradle will ignore this package unless 'core.jar' exists in this directory. That jar can be found in your Processing installation at process-XXX/core/library/core.jar, where XXX is installed version of processing. Unfortunately there is no officially supported version of Processing on Maven central so it cannot be automatically installed. Which is why you have to do this manual hackery.
			</blockquote>


			== API and Usage Examples ==
			Click below for a complete set of usage examples on GitHub:
			* [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples boofcv/integration/processing/examples]

			Browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than general BoofCV API and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.

	Consult the [https://github.com/lessthanoptimal/BoofCV/blob/master/integration/processing/README.TXT README.TXT] for instructions on how to build Processing support using Gradle.		Consult the [https://github.com/lessthanoptimal/BoofCV/blob/master/integration/processing/README.TXT README.TXT] for instructions on how to build Processing support using Gradle.

Peter at 04:08, 10 June 2014

2014-06-10T04:08:47Z

← Older revision		Revision as of 04:08, 10 June 2014
Line 6:		Line 6:

	Usage examples can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples GitHub in the examples directory] and browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than most of BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.		Usage examples can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples GitHub in the examples directory] and browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than most of BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.

			Consult the [https://github.com/lessthanoptimal/BoofCV/blob/master/integration/processing/README.TXT README.TXT] for instructions on how to build Processing support using Gradle.

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">

Peter at 04:06, 10 June 2014

2014-06-10T04:06:28Z

← Older revision		Revision as of 04:06, 10 June 2014
Line 5:		Line 5:
	</blockquote>		</blockquote>

	Usage examples can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples GitHub in the examples directory]. The interface provided is more object oriented than most of BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour.		Usage examples can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples GitHub in the examples directory] and browsing through those examples is the best way to learn how to use BoofCV in processing. The interface provided is more object oriented than most of BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour. Operations which don't have a nice easy to use interface can also be used. Just code them up as usual.

	<syntaxhighlight lang="java">		<syntaxhighlight lang="java">

Peter: Created page with "BoofCV provides an easy to use interface tailored for [http://processing.org Processing]. Don't know what Processing is? Here is a summary taken from its website:
2014-06-10T04:04:47Z

Created page with "BoofCV provides an easy to use interface tailored for [http://processing.org Processing]. Don't know what Processing is? Here is a summary taken from its website: <blockquot..."

New page
BoofCV provides an easy to use interface tailored for [http://processing.org Processing]. Don't know what Processing is? Here is a summary taken from its website:

<blockquote>
Processing is a programming language, development environment, and online community. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. Initially created to serve as a software sketchbook and to teach computer programming fundamentals within a visual context, Processing evolved into a development tool for professionals. Today, there are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning, prototyping, and production.
</blockquote>

Usage examples can be found on [https://github.com/lessthanoptimal/BoofCV/tree/master/integration/processing/examples GitHub in the examples directory]. The interface provided is more object oriented than most of BoofCV and allows for commands to be chained in a sequence. Consider the example below, contours are found by chaining several commands together; threshold, erode, and contour.

<syntaxhighlight lang="java">
import boofcv.processing.;
import boofcv.struct.image.;

PImage imgContour;
PImage imgBlobs;

void setup() {

PImage input = loadImage("particles01.jpg");

// Convert the image into a simplified BoofCV data type
SimpleGray gray = Boof.gray(input,ImageDataType.F32);

// Threshold the image using its mean value
double threshold = gray.mean();

// find blobs and contour of the particles
ResultsBlob results = gray.threshold(threshold,true).erode8(1).contour();

// Visualize the results
imgContour = results.getContours().visualize();
imgBlobs = results.getLabeledImage().visualize();

size(input.width, input.height);
}

void draw() {
background(0);
if( mousePressed ) {
image(imgBlobs, 0, 0);
} else {
image(imgContour, 0, 0);
}
}
</syntaxhighlight>