Tutorial Quick Start

From BoofCV
Jump to: navigation, search

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 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:

Step Two: Running Examples and Demonstrations

Examples are short pieces of code which are designed to be easy to understand and show you how to perform some task. Demonstrations are more complex applications which visualize different aspects of an algorithm. The code for a demonstration is not designed to be easy to learn from and can be quite complex due to its integration with a GUI.

Source Code:

The easiest way to run an example or demonstration is to launch their respective master applications. You can also load up the source code in your favorite IDE and run the applications directly.

cd boofcv
./gradlew examples
java -jar examples/examples.jar
./gradlew demonstrations
java -jar demonstrations/demonstrations.jar


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

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

BoofCV supports 3 types of images; Gray (single band images), Planar (multi-band in a planar format), and Interleaved (traditional multi-band image format). The first two, gray and planar are fully supported while interleaved is partially supported. Gray and planar images are just easier to work with most of the time which is why they are fully supported. Interleaved is only supported where there is a performance advantage that was significant.

GrayU8 image = new GrayU8(100,150);

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

GrayF32 image = new GrayF32(100,150);

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

Planar<GrayU8> image = new Planar<GrayU8>(GrayU8.class,100,200,3);

Creates a color planar image with 3 bands using GrayU8 for each band.

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

Loads a single band image of type GrayF32 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);

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( GrayF32 image )
	float pixel = image.get(5,23);

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( GrayU8 image )
	int pixel = image.get(5,23);

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( GrayI image )
	int pixel = image.get(5,23);

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( Planar<GrayU8> image )
	int pixel = image.getBand(0).get(5,23);

Planar images are essentially arrays of ImageGray. 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.


public static void procedural( GrayU8 input )
	GrayU8 blurred = new GrayU8(input.width,input.height);

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

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

	T blurred = GeneralizedImageOps.createSingleBand(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 ImageGray, D extends ImageGray>
void filter( T input )
	Class<T> inputType = (Class<T>)input.getClass();
	T blurred = GeneralizedImageOps.createSingleBand(inputType, input.width, input.height);
	BlurFilter<T> filterBlur = FactoryBlurFilter.gaussian(inputType, -1, blurRadius);

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);

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

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

	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 GrayU8.

binary = BinaryImageOps.erode8(binary, 1, null);

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

BinaryImageOps.erode8(binary, 1, output);

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

BinaryImageOps.erode4(binary, 1, output);

Apply an erode operation once with a 4-connect rule.

int numBlobs = BinaryImageOps.contour(binary, ConnectRule.FOUR, blobs).size();

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

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

Renders the detected blobs in a colored image.

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

Renders the binary image as a black white image. false means the colors are not inverted.

Suggested Hardware

To do computer vision you need a camera. Here's a list of recommended cameras

Webcams are great for basically everything but structure from motion (SFM) applications. Their images often look better than much more expensive scientific cameras. Unfortunately they have a rolling shutter which breaks SFM algorithms if anything in the scene or the camera is moving.

The Theta S is a 360 camera composed of two fisheye cameras. Interestingly it is one of the few consumer grade cameras to provide a global shutter! Making it useful for SFM applications.

(The above links are Amazon affiliate. If you do plan on purchasing one of those cameras please help finance BoofCV and click on those links.)