Tutorial Quick Start

The following tutorial is intended to provide just enough information for you to quickly set up and start development with BoofCV. If you are not familiar with the Java programming language or its associated development tools, you must fix that first because BoofCV is written entirely in Java. It is highly recommended that you use a tool like Gradle or Maven to build your own project and have it download the jars for you. If you enjoy doing things the slow and tedious way we are there for you and provide all the jars.

Step One: Obtaining

The first step in using BoofCV is either adding it to your dependency list, downloading the precompiled Jars, or building it from Source.

Latest Official Release:

• Source Code Download Page
• Jars Download Page
• Maven and Gradle Download Page

Step Two: Running Examples

For this step you must have the source code checked out from github or downloaded. Just having the jars is not enough. Do that now if you haven't already.

Before you try to run the examples make sure you have all the data they use! The data is stored in a submodule in boofcv/data, which is initially empty if you pulled the source code from Github. If you download the source code then you should have the entire data directory. The easiest way to get the data directory is to pull it from git:

cd boofcv/
git submodule init
git submodule update

Once you do that you are almost ready to run the examples.

BoofCV is built using Gradle. Gradle can be imported into IntelliJ or Eclipse. For instructions on how to do that see the project README.md document. Then in your IDE you can navigate to the examples directory, right click and select run.

If you have Gradle installed in your system, then it's very easy to run examples. For full instructions see examples/readme.txt

gradle exampleRun -Pwhich=boofcv.examples.imageprocessing.ExampleBinaryOps

You can now explore all the example. I recommend trying them out on your own images/data as well as changing parameters and seeing what happens.

HELP ME!!

Having trouble or have a suggestion? Post a message on the BoofCV message board! Don't worry it's a friendly place.

• Message Board

Quick Reference

The remainder of this tutorial is intended to act as a quick reference of low level image processing routines in BoofCV.

Term	definition
single band	The image supports only one color
floating point	Image elements are of type float or double
unsigned	Image elements can only be positive integers
signed	Image elements can be either positive or negative integers
generics	Allows strong typing in abstracted code. Introduced in Java 1.5. Click here.

The Basics

ImageUInt8 image = new ImageUInt8 (100,150);

Creating an unsigned 8-bit integer single band image with width=100 and height=150.

ImageFloat32 image = new ImageFloat32(100,150);

Creating a floating point single band image with width=100 and height=150.

MultiSpectral<ImageUInt8> image = new MultiSpectral<ImageUInt8>(ImageUInt8.class,100,200,3);

Creates a color multi spectral image with 3 bands using ImageUInt8 for each band.

ImageFloat32 image = UtilImageIO.loadImage("test.png",ImageFloat32.class);

Loads a single band image of type ImageFloat32 from a file.

public static <T extends ImageBase> T generic( Class<T> imageType ) {
	T image = UtilImageIO.loadImage("test.png",imageType);

Loads an image with the specified type inside a function that uses Java generics.

BufferedImage out = ConvertBufferedImage.convertTo(image,null);

Converts an image into a BufferedImage to provide better integration with Java2D (display/saving). Pixel values must be in the range of 0 to 255.

BufferedImage out = VisualizeImageData.grayMagnitude(derivX,null,-1);

Renders a signed single band image into a gray intensity image.

BufferedImage out = VisualizeImageData.colorizeSign(derivX,null,-1);

Renders a signed single band image into a color intensity image.

BufferedImage out = ConvertBufferedImage.convertTo(image,null);
ShowImages.showWindow(out,"Output");

Displays an image in a window using Java swing.

Pixel Access

The image type must be known to access pixel information. The following show how to access pixels for different image types. For more information on the image data structure and direct access to the raw data array see Tutorial Images for more details

public static void function( ImageFloat32 image )
{
	float pixel = image.get(5,23);
	image.set(5,23,50.3);

Gets and sets the pixel at (5,23). Note that set() and get() functions are image type specific. In other words, you can't access pixel without knowing the image type.

public static void function( ImageUInt8 image )
{
	int pixel = image.get(5,23);
	image.set(5,23,50);

Similar to the above example but for an 8-bit unsigned integer image. Note the image.get() returns 'int' and not 'byte'.

public static void function( ImageInteger image )
{
	int pixel = image.get(5,23);
	image.set(5,23,50);

In fact the same code will work for all integer images, except SInt64 which uses longs and not ints. Internally UInt8 stores its pixels as a byte array, but set() and get() return int because Java internally does not use bytes on the register.

public static void function( MultiSpectral<ImageUInt8> image )
{
	int pixel = image.getBand(0).get(5,23);
	image.getBand(0).set(5,23,50);

MultiSpectral images are essentially arrays of ImageSingleBands. To set or get a pixel value first access the particular band that needs to be changed then use the standard accessors inside of ImageSingleBand.

Filters

public static void procedural( ImageUInt8 input )
{
	ImageUInt8 blurred = new ImageUInt8(input.width,input.height);
	BlurImageOps.gaussian(input,blurred,-1,blurRadius,null);

Applies Gaussian blur to an image using a type specific procedural interface.

public static <T extends ImageSingleBand, D extends ImageSingleBand>
void generalized( T input )
{
	Class<T> inputType = (Class<T>)input.getClass();

	T blurred = GeneralizedImageOps.createImage(inputType,input.width, input.height);
	GBlurImageOps.gaussian(input, blurred, -1, blurRadius, null);

Applies Gaussian blur to an image using an abstracted procedural interface. Note the G in front of BlurImageOps that indicates it contains generic functions.

public static <T extends ImageSingleBand, D extends ImageSingleBand>
void filter( T input )
{
	Class<T> inputType = (Class<T>)input.getClass();
	T blurred = GeneralizedImageOps.createImage(inputType, input.width, input.height);
	BlurFilter<T> filterBlur = FactoryBlurFilter.gaussian(inputType, -1, blurRadius);
	filterBlur.process(input,blurred);

Creates an image filter class for computing the Gaussian blur. Provides greater abstraction.

// type specific sobel
GradientSobel.process(blurred, derivX, derivY, FactoryImageBorder.extend(input));
// generic
GImageDerivativeOps.sobel(blurred, derivX, derivY, BorderType.EXTENDED);
// filter
ImageGradient<T,D> gradient = FactoryDerivative.sobel(inputType, derivType);
gradient.process(blurred,derivX,derivY);

Three ways to compute the image gradient using a Sobel kernel.

public static <T extends ImageSingleBand, D extends ImageSingleBand>
void example( T input , Class<D> derivType ) {
	AnyImageDerivative<T,D> deriv = GImageDerivativeOps.createDerivatives((Class<T>)input.getClass(),derivType);

	deriv.setInput(input);
	D derivX = deriv.getDerivative(true);
	D derivXXY = deriv.getDerivative(true,true,false);

Useful class for computing arbitrary image derivatives. Computes 1st order x-derive and then 3rd order xxy derivative.

Binary Images

ThresholdImageOps.threshold(image, binary, 23, true);

Creates a binary image by thresholding the input image. Binary must be of type ImageUInt8.

binary = BinaryImageOps.erode8(binary,null);

Apply an erode operation on the binary image, writing over the original image reference.

BinaryImageOps.erode8(binary,output);

Apply an erode operation on the binary image, saving results to the output binary image.

BinaryImageOps.erode4(binary,output);

Apply an erode operation with a 4-connect rule.

int numBlobs = BinaryImageOps.labelBlobs4(binary,blobs);

Detect and label blobs in the binary image using a 4-connect rule. blobs is an image of type ImageSInt32.

BufferedImage visualized = VisualizeBinaryData.renderLabeled(blobs, numBlobs, null);

Renders the detected blobs in a colored image.

BufferedImage visualized = VisualizeBinaryData.renderBinary(binary,null);

Renders the binary image as a black white image.