de.unihalle.informatik.MiToBo.segmentation.thresholds

Class ImgThreshNiblack

java.lang.Object

de.unihalle.informatik.Alida.operator.ALDOperator

de.unihalle.informatik.MiToBo.core.operator.MTBOperator

de.unihalle.informatik.MiToBo.segmentation.thresholds.ImgThreshNiblack

All Implemented Interfaces:

de.unihalle.informatik.Alida.datatypes.ALDConfigurationValidator, de.unihalle.informatik.Alida.operator.events.ALDOperatorExecutionProgressEventListener, EventListener

@ALDAOperator(genericExecutionMode=ALL,
              shortDescription="Image binarization based on local Niblack thresholding.")
public class ImgThreshNiblack
extends MTBOperator

Image binarization based on local Niblack thresholding.

The implementation is based upon the following publications:

• W. Niblack, An Introduction to Digital Image Processing, pp. 115-116, Prentice Hall, 1986.
• G. Leedham, C. Yan, et al., Comparison of some thresholding algorithms for text/background segmentation in difficult document images,
  Proc. of the Seventh International Conference on Document Analysis and Recognition. Vol. 2. 2003
• Z. Zhang, C.L. Tan, Recovery of Distorted Document Images from Bound Values, Proc. of 6th International Conference on Document Analysis and Recognition, pp. 429-433, 2001.

Note that the enhanced Niblack mode as proposed by Zhang et al. is quite similar to the Sauvola local thresholding approach published in

• Sauvola, J and Pietikainen, M (2000), Adaptive document image binarization, Pattern Recognition 33(2): 225-236

This class implements various versions of the Niblack thresholding approach. It calculates local thresholds according to the given input parameters and applies them to the given image. As result a binary image is returned.

Provided methods include conventional and enhanced Niblack thresholding, either applied in a sliding window manner or maskwise. In the latter case the windows are not overlapping. The maskwise application has particularly profen suitable for granule detection.
The operator allows for activation of an additional local variance check. If activated, only windows are thresholded where the variance exceeds a certain threshold. All other windows are assumed to contain more or less homogeneous intensities and are classified as background.

In standard mode, as proposed by Niblack, the operator calculates a local threshold T based on the local mean m and standard deviation s in a local sliding window around pixel (x,y):

\begin{equation*} T(x,y) = m(x,y) + k \cdot s(x,y) \end{equation*}

k is a scaling constant which has to be chosen depending on the application at hand. As stated above, this mode can be combined with additional variance checks.

In additon to the standard version of the Niblack approach the operator also implements an enhanced version as proposed by Zhang et al:

\begin{equation*} T(x,y) = m(x,y) \cdot \left( 1 + k \cdot \left( 1 - \frac{s(x,y)}{R} \right) \right) \end{equation*}

This version can be selected in standard mode by setting the parameter R to a value different from -1. In the original paper default values of R = 100 and k = 0.1 are suggested. This mode can also be combined with local variance checks.

Author:

moeller

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ImgThreshNiblack.Mode Niblack processing mode.

Nested classes/interfaces inherited from class de.unihalle.informatik.Alida.operator.ALDOperator

de.unihalle.informatik.Alida.operator.ALDOperator.HidingMode, de.unihalle.informatik.Alida.operator.ALDOperator.HistoryConstructionMode

Field Summary

Fields

Modifier and Type	Field and Description
private double	enhanceR Niblack factor R.
private MTBImage	inImg Input image.
private MTBImageByte	mask Optional mask for excluding image regions from processing.
private MTBImageByte	outImg Binary result image.
private ImgThreshNiblack.Mode	processMode Process mode.
private double	scalingK Niblack scaling parameter k.
private int	varCheckNB Size of neighborhood for local variance checks.
private double	varCheckThresh Threshold for variance check.
private int	winSize Size of local sliding window.

Fields inherited from class de.unihalle.informatik.Alida.operator.ALDOperator

completeDAG, name, operatorExecutionEventlistenerList, portHashAccess, verbose, versionProvider

Constructor Summary

Constructors

Constructor and Description
ImgThreshNiblack() Default constructor.
ImgThreshNiblack(MTBImage _inImg, ImgThreshNiblack.Mode mode, double k, double R, int wSize, int vcNB, double vcThresh, MTBImageByte _mask) Constructor.

Method Summary

Modifier and Type	Method and Description
private MTBImageByte	applyNiblackThreshold_withLocalVarCheck(MTBImage mimg, int w, double k, double R, int varCheckNeighborhood, double localVarThresh) This function implements the conventional Niblack binarization, enhanced with a local variance check.
private MTBImageByte	applyNiblackThreshold(MTBImage mimg, int w, double k, double R) This function implements the conventional (enhanced) Niblack binarization.
private MTBImageByte	applyNiblackThresholdMaskwise(MTBImage mimg, int w, double k, double R) Enhanced Niblack binarization applied maskwise to the image, i.e. all pixels inside the mask get the same threshold.
ij.ImagePlus	applyNiblackThresholdWholeImage(ij.process.ImageProcessor ip, double k, double R, ij.ImagePlus _mask) Deprecated.
private MTBImageByte	applyNiblackThresholdWholeImage(MTBImage mimg, double k, double R) This function implements the conventional (enhanced) Niblack binarization.
String	getDocumentation()
MTBImageByte	getResultImage() Get the resulting thresholded image.
protected void	operate()
void	setInputImage(MTBImage img) Set input image.

Methods inherited from class de.unihalle.informatik.MiToBo.core.operator.MTBOperator

readResolve

Methods inherited from class de.unihalle.informatik.Alida.operator.ALDOperator

addOperatorExecutionProgressEventListener, addParameter, addParameter, addParameterUnconditioned, fieldContained, fireOperatorExecutionProgressEvent, getALDPortHashAccessKey, getConstructionMode, getHidingMode, getInactiveParameterNames, getInInoutNames, getInInoutNames, getInNames, getInOutNames, getMissingRequiredInputs, getName, getNumParameters, getOutInoutNames, getOutNames, getParameter, getParameterDescriptor, getParameterDescriptorUnconditioned, getParameterNames, getParameterUnconditioned, getSupplementalNames, getVerbose, getVersion, handleOperatorExecutionProgressEvent, hasInOutParameters, hasParameter, isAnnotatedParameter, isConfigured, print, print, print, printInterface, printInterface, readHistory, reinitializeParameterDescriptors, removeOperatorExecutionProgressEventListener, removeParameter, runOp, runOp, runOp, setConstructionMode, setConstructionMode, setConstructionMode, setHidingMode, setName, setParameter, setParameterUnconditioned, setVerbose, toStringVerbose, unconfiguredItems, validate, validateCustom, validateGeneric, writeHistory, writeHistory, writeHistory

Methods inherited from class java.lang.Object

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

Field Detail

inImg

@Parameter(label="Input image",
           required=true,
           direction=IN,
           description="Input image.")
private transient MTBImage inImg

Input image.

outImg

@Parameter(label="Result image",
           required=true,
           direction=OUT,
           description="Output image.")
private transient MTBImageByte outImg

Binary result image.

processMode

@Parameter(label="Mode",
           required=true,
           direction=IN,
           description="Process Mode.")
private ImgThreshNiblack.Mode processMode

Process mode.

scalingK

@Parameter(label="K",
           direction=IN,
           description="Scaling factor K.",
           dataIOOrder=-8)
private double scalingK

Niblack scaling parameter k.

enhanceR

@Parameter(label="R",
           direction=IN,
           description="Enhancement factor R, disabled if -1.",
           dataIOOrder=-7)
private double enhanceR

Niblack factor R.

winSize

@Parameter(label="Window size",
           direction=IN,
           description="Local window size.",
           dataIOOrder=-15)
private int winSize

Size of local sliding window.

varCheckThresh

@Parameter(label="Variance threshold",
           direction=IN,
           description="Variance check threshold",
           dataIOOrder=-4)
private double varCheckThresh

Threshold for variance check.

Image areas with a variance below the threshold are classified as background because the Niblack criterion will most likely fail.

See Also:

varCheckNB

varCheckNB

@Parameter(label="Variance check neighborhood",
           direction=IN,
           dataIOOrder=-5,
           description="Variance check neighborhood size.")
private int varCheckNB

Size of neighborhood for local variance checks.

See Also:

varCheckThresh

mask

@Parameter(label="Exclude Mask",
           direction=IN,
           required=false,
           description="Exclude mask",
           dataIOOrder=-10)
private MTBImageByte mask

Optional mask for excluding image regions from processing.

Constructor Detail

ImgThreshNiblack

public ImgThreshNiblack()
                 throws de.unihalle.informatik.Alida.exceptions.ALDOperatorException

Default constructor.

Throws:

de.unihalle.informatik.Alida.exceptions.ALDOperatorException - Thrown in case of failure.

ImgThreshNiblack

public ImgThreshNiblack(MTBImage _inImg,
                        ImgThreshNiblack.Mode mode,
                        double k,
                        double R,
                        int wSize,
                        int vcNB,
                        double vcThresh,
                        MTBImageByte _mask)
                 throws de.unihalle.informatik.Alida.exceptions.ALDOperatorException

Constructor. A new empty meta data object is initialized.

Parameters:

_inImg - Image to work on.

mode - Mode for Niblack operator.

k - Scaling factor for standard deviation.

R - If unequal to -1, enhanced Niblack is applied.

wSize - Size of sliding window for local thresholding.

vcNB - Size of neighborhood for local variance check.

vcThresh - Threshold for local variance check.

_mask - Image mask for excluding image sections.

Throws:

de.unihalle.informatik.Alida.exceptions.ALDOperatorException - Thrown in case of failure.

Method Detail

getResultImage

public MTBImageByte getResultImage()

Get the resulting thresholded image.

Returns:

Binary image.

setInputImage

public void setInputImage(MTBImage img)

Set input image.

Parameters:

img - Image to process.

operate

protected void operate()

Specified by:

operate in class de.unihalle.informatik.Alida.operator.ALDOperator

applyNiblackThreshold

private MTBImageByte applyNiblackThreshold(MTBImage mimg,
                                           int w,
                                           double k,
                                           double R)

This function implements the conventional (enhanced) Niblack binarization. If R equals -1, the non-enhanced conventional variant is used.

Parameters:

mimg - Input image to process.

w - Size of sliding window.

k - Niblack factor.

R - Niblack normalization constant.

Returns:

Niblack thresholded image.

LaTeX:

Niblack binarization: \begin{eqnarray*} t &=& \mu + k \cdot ( \mu \cdot ( 1 - \sigma / R ) ). \\ \end{eqnarray*}

applyNiblackThresholdMaskwise

private MTBImageByte applyNiblackThresholdMaskwise(MTBImage mimg,
                                                   int w,
                                                   double k,
                                                   double R)

Enhanced Niblack binarization applied maskwise to the image, i.e. all pixels inside the mask get the same threshold. The threshold is calculated as

\begin{equation*} t = \mu + k * ( \mu \cdot ( 1 - \sigma / R ) ), \end{equation*}

if R does not equal -1. Otherwise, the conventional variant

\begin{equation*} t = \mu + k \cdot \sigma \end{equation*}

is used. The main difference is here, that compared to the original approach, thresholds are not calculated pixelwise, but just maskwise. In detail, the mask of given size w is shifted to non-overlapping locations, for each location a threshold is calculated and then applied to all pixels within the mask. NOTE: The parameter mask is ignored for the moment!

applyNiblackThreshold_withLocalVarCheck

private MTBImageByte applyNiblackThreshold_withLocalVarCheck(MTBImage mimg,
                                                             int w,
                                                             double k,
                                                             double R,
                                                             int varCheckNeighborhood,
                                                             double localVarThresh)

This function implements the conventional Niblack binarization, enhanced with a local variance check. If parameter R does not equal -1 the method applies the threshold \begin{equation*} t = \mu + k * ( \mu \cdot ( 1 - \sigma / R ) ) \end{equation*}. If R equals -1, the conventional variant is used, i.e., \begin{equation*} t = \mu + k \cdot \sigma \end{equation*}. In addition, a local variance check in a 7x7-windows around each pixel takes place. Only if the local variance exceeds a certain threshold the Niblack threshold is considered, otherwise the pixel is set to zero, i.e. background. This function is specifically dedicated to image with large homogeneous regions where standard Niblack thresholding results in errorneous detection results.

applyNiblackThresholdWholeImage

@Deprecated
public ij.ImagePlus applyNiblackThresholdWholeImage(ij.process.ImageProcessor ip,
                                                                double k,
                                                                double R,
                                                                ij.ImagePlus _mask)

Deprecated.

applyNiblackThresholdWholeImage

private MTBImageByte applyNiblackThresholdWholeImage(MTBImage mimg,
                                                     double k,
                                                     double R)

This function implements the conventional (enhanced) Niblack binarization. If R equals -1, the non-enhanced conventional variant is used. Here no sliding window is required since the whole image area is taken as input image region. Consequently this method does a global binarization applying a single threshold on each image pixel.

Parameters:

ip - input image processor

k - Niblack factor

R - Niblack normalization constant

Returns:

Niblack thresholded image.

LaTeX:

Niblack binarization: \begin{eqnarray*} t &=& \mu + k \cdot ( \mu \cdot ( 1 - \sigma / R ) ). \\ \end{eqnarray*}

getDocumentation

public String getDocumentation()

Overrides:

getDocumentation in class de.unihalle.informatik.Alida.operator.ALDOperator