Binarize

com.googlecode.leptonica.android.Binarize

```
public class Binarize
```
Image binarization methods.

- Field Detail
  - OTSU_SIZE_X
```
public static int OTSU_SIZE_X
```
    Desired tile X dimension; actual size may vary
    
    See Also:
    
    Constant Field Values
  - OTSU_SIZE_Y
```
public static int OTSU_SIZE_Y
```
    Desired tile Y dimension; actual size may vary
    
    See Also:
    
    Constant Field Values
  - OTSU_SMOOTH_X
```
public static int OTSU_SMOOTH_X
```
    Desired X smoothing value
    
    See Also:
    
    Constant Field Values
  - OTSU_SMOOTH_Y
```
public static int OTSU_SMOOTH_Y
```
    Desired Y smoothing value
    
    See Also:
    
    Constant Field Values
  - OTSU_SCORE_FRACTION
```
public static float OTSU_SCORE_FRACTION
```
    Fraction of the max Otsu score, typically 0.1
    
    See Also:
    
    Constant Field Values
  - SAUVOLA_DEFAULT_WINDOW_HALFWIDTH
```
public static int SAUVOLA_DEFAULT_WINDOW_HALFWIDTH
```
    See Also:
    
    Constant Field Values
  - SAUVOLA_DEFAULT_REDUCTION_FACTOR
```
public static float SAUVOLA_DEFAULT_REDUCTION_FACTOR
```
    See Also:
    
    Constant Field Values
  - SAUVOLA_DEFAULT_NUM_TILES_X
```
public static int SAUVOLA_DEFAULT_NUM_TILES_X
```
    See Also:
    
    Constant Field Values
  - SAUVOLA_DEFAULT_NUM_TILES_Y
```
public static int SAUVOLA_DEFAULT_NUM_TILES_Y
```
    See Also:
    
    Constant Field Values
- 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:
    
    org.jetbrains.dokka.NodeRenderContent@4aef30a0: A 1 bpp thresholded PIX image.
  - otsuAdaptiveThreshold
```
public static Pix otsuAdaptiveThreshold(Pix pixs,
                                        int sizeX,
                                        int sizeY,
                                        int smoothX,
                                        int smoothY,
                                        @FloatRange
                                        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:
    
    org.jetbrains.dokka.NodeRenderContent@2e22c62d: 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:
    
    org.jetbrains.dokka.NodeRenderContent@34b220ef: A 1 bpp thresholded PIX image.
    
    See Also:
    
    #sauvolaBinarizeTiled(Pix, int, float, int, int)
  - sauvolaBinarizeTiled
```
public static Pix sauvolaBinarizeTiled(Pix pixs,
                                       int whsize,
                                       @FloatRange
                                       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:
    
    org.jetbrains.dokka.NodeRenderContent@583ff725: A 1 bpp thresholded PIX image.

Class Binarize

Field Detail

OTSU_SIZE_X

OTSU_SIZE_Y

OTSU_SMOOTH_X

OTSU_SMOOTH_Y

OTSU_SCORE_FRACTION

SAUVOLA_DEFAULT_WINDOW_HALFWIDTH

SAUVOLA_DEFAULT_REDUCTION_FACTOR

SAUVOLA_DEFAULT_NUM_TILES_X

SAUVOLA_DEFAULT_NUM_TILES_Y

Method Detail

otsuAdaptiveThreshold

otsuAdaptiveThreshold

sauvolaBinarizeTiled

sauvolaBinarizeTiled