org.openimaj.image.processing.convolution

Class FImageConvolveSeparable

java.lang.Object

org.openimaj.image.processing.convolution.FImageConvolveSeparable

All Implemented Interfaces:

ImageProcessor<FImage>, Processor<FImage>, SinglebandImageProcessor<Float,FImage>

public class FImageConvolveSeparable
extends Object
implements SinglebandImageProcessor<Float,FImage>

Image processor for separable convolution of an FImage. Capable of doing convolution in either the vertical, horizontal or both directions.

Author:

Jonathon Hare (jsh2@ecs.soton.ac.uk)

Nested Class Summary

Nested classes/interfaces inherited from interface org.openimaj.image.processor.SinglebandImageProcessor

SinglebandImageProcessor.Processable<T,S extends Image<T,S>,I extends Image<?,I>>

Constructor Summary

Constructors

Constructor and Description
FImageConvolveSeparable(float[] kernel) Specify a single kernel to be used as the horizontal and vertical.
FImageConvolveSeparable(float[] hkernel, float[] vkernel) Specify the horizontal kernel and vertical kernel separately.

Method Summary

Modifier and Type	Method and Description
protected static void	convolveBuffer(float[] buffer, float[] kernel)
static void	convolveHorizontal(FImage image, float[] kernel) Convolve the image in the horizontal direction with the kernel.
static void	convolveVertical(FImage image, float[] kernel) Convolve the image in the vertical direction with the kernel.
static void	fastConvolve3(FImage source, FImage dest, float[] kx, float[] ky, float[] buffer) Fast convolution for separated 3x3 kernels.
void	processImage(FImage image) Process an image.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FImageConvolveSeparable

public FImageConvolveSeparable(float[] hkernel,
                               float[] vkernel)

Specify the horizontal kernel and vertical kernel separately.

Parameters:

hkernel - horizontal kernel

vkernel - vertical kernel

FImageConvolveSeparable

public FImageConvolveSeparable(float[] kernel)

Specify a single kernel to be used as the horizontal and vertical.

Parameters:

kernel - both kernels

Method Detail

processImage

public void processImage(FImage image)

Description copied from interface: ImageProcessor

Process an image. Implementing classes must alter the image passed in-place or assign the output to the input using Image.internalAssign(Image).

Specified by:

processImage in interface ImageProcessor<FImage>

Parameters:

image - The image to process in place.

convolveBuffer

protected static void convolveBuffer(float[] buffer,
                                     float[] kernel)

convolveHorizontal

public static void convolveHorizontal(FImage image,
                                      float[] kernel)

Convolve the image in the horizontal direction with the kernel. Edge effects are handled by duplicating the edge pixels.

Parameters:

image - the image to convolve.

kernel - the convolution kernel.

convolveVertical

public static void convolveVertical(FImage image,
                                    float[] kernel)

Convolve the image in the vertical direction with the kernel. Edge effects are handled by duplicating the edge pixels.

Parameters:

image - the image to convolve.

kernel - the convolution kernel.

fastConvolve3

public static void fastConvolve3(FImage source,
                                 FImage dest,
                                 float[] kx,
                                 float[] ky,
                                 float[] buffer)

Fast convolution for separated 3x3 kernels. Only valid pixels are considered, so the output image bounds will be two pixels smaller than the input image on all sides (the response of the kernel to the source pixel at 1,1 is stored in the destination image at 0,0)

Parameters:

source - the source image

dest - the destination image

kx - the x-kernel (can be null, implying [0 1 0] )

ky - the y-kernel (can be null, implying [0 1 0])

buffer - the working buffer (can be null, but ideally the same width as the source image)