com.googlecode.leptonica.android

Class Binarize

java.lang.Object

com.googlecode.leptonica.android.Binarize

public class Binarize
extends Object

Image binarization methods.

Field Summary

Fields

Modifier and Type	Field and Description
static float	OTSU_SCORE_FRACTION Fraction of the max Otsu score, typically 0.1
static int	OTSU_SIZE_X Desired tile X dimension; actual size may vary
static int	OTSU_SIZE_Y Desired tile Y dimension; actual size may vary
static int	OTSU_SMOOTH_X Desired X smoothing value
static int	OTSU_SMOOTH_Y Desired Y smoothing value
static int	SAUVOLA_DEFAULT_NUM_TILES_X
static int	SAUVOLA_DEFAULT_NUM_TILES_Y
static float	SAUVOLA_DEFAULT_REDUCTION_FACTOR
static int	SAUVOLA_DEFAULT_WINDOW_HALFWIDTH

Constructor Summary

Constructors

Constructor and Description
Binarize()

Method Summary

Modifier and Type	Method and Description
static Pix	otsuAdaptiveThreshold(Pix pixs) Performs locally-adaptive Otsu threshold binarization with default parameters.
static Pix	otsuAdaptiveThreshold(Pix pixs, int sizeX, int sizeY, int smoothX, int smoothY, float scoreFraction) Performs locally-adaptive Otsu threshold binarization.
static Pix	sauvolaBinarizeTiled(Pix pixs) Performs Sauvola binarization using default values.
static Pix	sauvolaBinarizeTiled(Pix pixs, int whsize, float factor, int nx, int ny) Performs Sauvola binarization.

Methods inherited from class java.lang.Object

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

Field Detail

OTSU_SIZE_X

public static final int OTSU_SIZE_X

Desired tile X dimension; actual size may vary

See Also:

Constant Field Values

OTSU_SIZE_Y

public static final int OTSU_SIZE_Y

Desired tile Y dimension; actual size may vary

See Also:

Constant Field Values

OTSU_SMOOTH_X

public static final int OTSU_SMOOTH_X

Desired X smoothing value

See Also:

Constant Field Values

OTSU_SMOOTH_Y

public static final int OTSU_SMOOTH_Y

Desired Y smoothing value

See Also:

Constant Field Values

OTSU_SCORE_FRACTION

public static final float OTSU_SCORE_FRACTION

Fraction of the max Otsu score, typically 0.1

See Also:

Constant Field Values

SAUVOLA_DEFAULT_WINDOW_HALFWIDTH

public static final int SAUVOLA_DEFAULT_WINDOW_HALFWIDTH

See Also:

Constant Field Values

SAUVOLA_DEFAULT_REDUCTION_FACTOR

public static final float SAUVOLA_DEFAULT_REDUCTION_FACTOR

See Also:

Constant Field Values

SAUVOLA_DEFAULT_NUM_TILES_X

public static final int SAUVOLA_DEFAULT_NUM_TILES_X

See Also:

Constant Field Values

SAUVOLA_DEFAULT_NUM_TILES_Y

public static final int SAUVOLA_DEFAULT_NUM_TILES_Y

See Also:

Constant Field Values

Constructor Detail

Binarize

public Binarize()

Method Detail

otsuAdaptiveThreshold

public static Pix otsuAdaptiveThreshold(Pix pixs)

Performs locally-adaptive Otsu threshold binarization with default parameters.

Parameters:

pixs - An 8 bpp PIX source image.

Returns:

A 1 bpp thresholded PIX image.

otsuAdaptiveThreshold

public static Pix otsuAdaptiveThreshold(Pix pixs,
                                        int sizeX,
                                        int sizeY,
                                        int smoothX,
                                        int smoothY,
                                        float scoreFraction)

Performs locally-adaptive Otsu threshold binarization.

Notes:

1. The Otsu method finds a single global threshold for an image. This function allows a locally adapted threshold to be found for each tile into which the image is broken up.
2. The array of threshold values, one for each tile, constitutes a highly downscaled image. This array is optionally smoothed using a convolution. The full width and height of the convolution kernel are (2 * smoothX + 1) and (2 * smoothY + 1).
3. The minimum tile dimension allowed is 16. If such small tiles are used, it is recommended to use smoothing, because without smoothing, each small tile determines the splitting threshold independently. A tile that is entirely in the image bg will then hallucinate fg, resulting in a very noisy binarization. The smoothing should be large enough that no tile is only influenced by one type (fg or bg) of pixels, because it will force a split of its pixels.
4. To get a single global threshold for the entire image, use input values of sizeX and sizeY that are larger than the image. For this situation, the smoothing parameters are ignored.
5. The threshold values partition the image pixels into two classes: one whose values are less than the threshold and another whose values are greater than or equal to the threshold. This is the same use of 'threshold' as in pixThresholdToBinary().
6. The scorefract is the fraction of the maximum Otsu score, which is used to determine the range over which the histogram minimum is searched. See numaSplitDistribution() for details on the underlying method of choosing a threshold.
7. This uses enables a modified version of the Otsu criterion for splitting the distribution of pixels in each tile into a fg and bg part. The modification consists of searching for a minimum in the histogram over a range of pixel values where the Otsu score is within a defined fraction, scoreFraction, of the max score. To get the original Otsu algorithm, set scoreFraction == 0.

Parameters:

pixs - An 8 bpp PIX source image.

sizeX - Desired tile X dimension; actual size may vary.

sizeY - Desired tile Y dimension; actual size may vary.

smoothX - Half-width of convolution kernel applied to threshold array: use 0 for no smoothing.

smoothY - Half-height of convolution kernel applied to threshold array: use 0 for no smoothing.

scoreFraction - Fraction of the max Otsu score; typ. 0.1 (use 0.0 for standard Otsu).

Returns:

A 1 bpp thresholded PIX image.

sauvolaBinarizeTiled

public static Pix sauvolaBinarizeTiled(Pix pixs)

Performs Sauvola binarization using default values.

Parameters:

pixs - An 8 bpp PIX source image.

Returns:

A 1 bpp thresholded PIX image.

See Also:

sauvolaBinarizeTiled(Pix, int, float, int, int)

sauvolaBinarizeTiled

public static Pix sauvolaBinarizeTiled(Pix pixs,
                                       int whsize,
                                       float factor,
                                       int nx,
                                       int ny)

Performs Sauvola binarization.

Notes:

1. The window width and height are 2 * whsize + 1. The minimum value for whsize is 2; typically it is >= 7.
2. For nx == ny == 1, this defaults to pixSauvolaBinarize().
3. Why a tiled version? (a) Because the mean value accumulator is a uint32, overflow can occur for an image with more than 16M pixels. (b) The mean value accumulator array for 16M pixels is 64 MB. The mean square accumulator array for 16M pixels is 128 MB. Using tiles reduces the size of these arrays. (c) Each tile can be processed independently, in parallel, on a multicore processor.
4. The Sauvola threshold is determined from the formula: t = m * (1 - k * (1 - s / 128)) where: t = local threshold m = local mean k = @factor (>= 0) [ typ. 0.35 ] s = local standard deviation, which is maximized at 127.5 when half the samples are 0 and half are 255.
5. The basic idea of Niblack and Sauvola binarization is that the local threshold should be less than the median value, and the larger the variance, the closer to the median it should be chosen. Typical values for k are between 0.2 and 0.5.

Parameters:

pixs - An 8 bpp PIX source image.

whsize - Window half-width for measuring local statistics

factor - Factor for reducing threshold due to variance; >= 0

nx - Subdivision into tiles; >= 1

ny - Subdivision into tiles; >= 1

Returns:

A 1 bpp thresholded PIX image.