From Classic to Cutting-Edge: A Near-Perfect Global Thresholding Approach with Machine Learning

Abstract

Image binarization is an important process in many computer-vision applications. This transforms the color space of the original image into black and white. Global thresholding is a quick and reliable way to achieve binarization, but it is inherently limited by image noise and uneven lighting. This paper introduces a global thresholding method that uses the results of classical global thresholding algorithms and other global image features to train a regression model via machine learning. We prove through nested cross-validation that the model can predict the best possible global threshold with an average F-measure of 90.86% and a confidence of 0.79%. We apply our approach to a popular computer vision problem, document image binarization, and compare popular metrics with the best possible values achievable through global thresholding and with the values obtained through the algorithms we used to train our model. Our results show a significant improvement over these classical global thresholding algorithms, achieving near-perfect scores on all the computed metrics. We also compared our results with state-of-the-art binarization algorithms and outperformed them on certain datasets. The global threshold obtained through our method closely approximates the ideal global threshold and could be used in a mixed local-global approach for better results.

1. Introduction

Image binarization is the process of converting an image with varying pixel intensities into one with only two: black and white. The simplest way of doing this is by choosing a threshold intensity and converting every pixel with a lower intensity to a black pixel in the binarized image and every pixel with a higher intensity to a white pixel. This is called global threshold image binarization. Choosing different thresholds for different pixels based on their neighborhoods is called local threshold image binarization.

A popular use case for image binarization is the preprocessing of document scans in preparation for digitization. For this use case, several datasets are available, containing low-quality images of documents and corresponding ground-truth images that have black pixels where there was text in the original image and white pixels everywhere else. The quality of the binarized image can be measured using objective metrics by comparing the binarized image to the ground-truth image.

Global algorithms operate in the image histogram domain, resulting in a complexity based on the number of pixel intensities in the image, whereas local algorithms operate on each pixel for a complexity based on the number of pixels in the image, which is always much larger than the number of pixel intensities. Generally, global algorithms are much faster than local ones but yield lower-quality results on low-quality images owing to uneven lighting, noise, etc. The faster processing time and lower complexity are ideal for real-time or resource-constrained applications, such as embedded systems. For any given image, the maximum possible binarization quality achievable through global thresholding is not necessarily the highest possible binarization quality. Local thresholding algorithms have no such limitations; however, their computational cost is higher, and they only consider features from surrounding pixels, making them prone to specific failures.

Global thresholding algorithms provide varying results based on the type of noise and lighting in an image. Non-uniform lighting can be mitigated by applying global algorithms to image patches, such as the patch-based methods presented by Tahseen et al. [1], resulting in a mixed global–local approach.

We propose a machine learning model whose novelty lies in employing various thresholds produced by classical global thresholding algorithms as input features alongside other global image features to produce results as close as possible to the highest possible quality achievable through global thresholding.

The proposed solution is described in detail in Section 2. Evaluation metrics that allow comparison of the performance of global thresholding on different images are defined, and the methodology for evaluating the tested algorithms and employed datasets is laid out.

Section 3 presents the results of the proposed solution and compares them with the classic global thresholding algorithms used as features and the best possible global threshold. The proposed solution outperformed the other algorithms and achieved results very close to the ideal threshold, with a promising confidence interval.

Section 4 presents a discussion based on the presented results and visual examples, followed by conclusions and possible avenues for future work in Section 5.

In the Following Subsections, Previous Works Are Presented and Divided into Classical and Deep-Learning-Based Approaches.

1.1. Classical Approaches

Classical approaches can be split into two categories, in terms of how they operate on the image histogram space, linear and non-linear solutions. While the linear methods are straightforward and efficient, they require further exploration in our context; thus, we have opted not to implement them yet. They could be added to the features in future work without changing the time complexity of the solution. On the other hand, non-linear approaches, while potentially more powerful in handling complex relationships, introduce significant complexity. Given this trade-off, we chose not to pursue these methods either, prioritizing simplicity and computation time in our current implementation.

Wang and Fan [2] define the optimal threshold as the one that maximizes the objective function of the one-dimensional Tsallis entropy correlation single-threshold method:

$$\begin{array}{c}{S}_q\left(t\right)={\displaystyle \frac{1}{q-1}}(2-{\displaystyle \sum _{i=0}^t}{\left({\displaystyle \frac{h\left(i\right)}{c\left(t\right)}}\right)}^q-{\displaystyle \sum _{i=t+1}^{I_{max}}}{\left({\displaystyle \frac{h\left(i\right)}{1-c\left(t\right)}}\right)}^q,\end{array}$$

(1)

where $q$ is a real number whose value can be experimented with.

Elen and Dönmez [3] separate the image histogram into three regions: $\alpha$ between $\mu -\sigma$ and $\mu +\sigma$, ${\beta }_L$ between 0 and $\mu -\sigma$, and ${\beta }_H$ between $\mu +\sigma$ and $I_{max}$, where $\mu$ is the average pixel value and $\sigma$ is the standard deviation. Then, they compute ${\mu }_{\alpha }={\sum }_{x\in \alpha }ip\left(i\right)$ and ${\mu }_{\beta }={\sum }_{x\in \beta }ip\left(i\right)$ where $\beta ={\beta }_L\cup {\beta }_H$. They define the optimum threshold as $T_{opt}=\left({\mu }_{\alpha }+{\mu }_{\beta }\right)/2$. They compared their algorithm to several PDE-based ones, such as Guo and He [4], Guo et al. [5], and Mahani et al. [6].

Bogiatzis and Papadopoulos [7] compute two threshold candidates using a fuzzy inclusion indicator based on Zadeh’s fuzzy implication and the following fuzzy entropy formula:

$$\begin{array}{c}{E}_1=2{\displaystyle \frac{\sum _{x\in X}\min \left(m_{A^C}\left(x\right),m_A\left(x\right)\right)}{\sum _{x\in X}\max \left(m_{A^C}\left(x\right),m_A\left(x\right)\right)}},\end{array}$$

(2)

where $X$ is the set of pixels in the image; $m_A\left(x\right)$ is the membership grade of $x$ in the fuzzy subset $A$; and $A^C$ is the complementary subset of $A$. Then, they compute a classification function and choose one of the two candidates based on a criterion.

Ashir [8] proposed a multilevel thresholding algorithm that can be extended to implement image binarization. It is based on computing the mean pixel intensity for the entire image $\mu$, generating a gradient image $I_g$ by computing the intensity difference between the original image and $\mu$, and computing the mean gradient pixel ${\mu }_g$. They choose the following threshold:

$$\begin{array}{c}\mathrm{T}=\left\{\begin{array}{c}\mathsf{\mu }-{\mathsf{\mu }}_g,if{\displaystyle \sum _{i=\mathsf{\mu }-{\mathsf{\mu }}_g}^{\mathsf{\mu }}}h\left(i\right)<{\displaystyle \sum _{i=\mathsf{\mu }}^{\mathsf{\mu }+{\mathsf{\mu }}_g}}h\left(i\right)\\ \mathsf{\mu }+{\mathsf{\mu }}_g, otherwise\end{array}\right..\end{array}$$

(3)

Rani et al. [9] proposed a longer algorithm that starts by computing the Laplacian of the image and subtracting the Laplacian from the image. Then, they slide a 5 × 5 window on the image and compute its average value in each position, resulting in an average image $I_{avg}$. The threshold $T$ is selected as

$$\begin{array}{c}T=\max \left(I_{avg}\right)+\mathrm{median}\left(\underset{\mathit{on\; each\; column}}{\min }\left(I_{avg}\right)\right).\end{array}$$

(4)

1.2. Deep-Learning Approaches

Deep-learning approaches currently dominate the state-of-the-art of document image binarization. Convolutional neural networks are the most popular implementation, followed by vision transformers, but both produce competitive results.

SAE [10] is an auto-encoder that harnesses a convolutional neural network to encode the original image into a probability map. A global threshold is then applied to the probability map to generate the binarized image. MRAM [11] uses a convolutional random field to generate the binarized image from a probability map produced by a multi-resolution attention model.

DeepOtsu [12] applies Otsu’s thresholding algorithm on an enhanced image generated by a convolutional neural network that iteratively removes noise from the original image. 2DMN [13] is a bidimensional morphological network that removes noise from the original image using simple operations such as dilation and erosion.

DD-GAN [14] is a dual discriminator generative adversarial network comprising two networks, one to process the image globally and one locally. A threshold is applied to the generated image to obtain the binarized image. Suh [15] uses six generative adversarial networks: four colour-independent ones that extract information from the input image and two that transform the output images of the first four into the final binarized image.

cGANs [16] use conditional generative adversarial networks to combine multi-scale information. First, text pixels are extracted from the original image at various scales, and then, the multi-scale binarized images are combined to obtain the final binarized image. DE-GAN [17] also uses conditional generative adversarial networks.

D2BFormer [18] uses a vision transformer for semantic segmentation, transforming the original image into a two-channel feature map, one channel for the foreground and the other for the background. They then use the feature map to binarize the original image.

DocDiff [19] consists of a coarse predictor, which recovers primary low-frequency information, and of a high-frequency residual refinement module, which predicts high-frequency information using diffusion models.

DocEntr [20] and DocBinFormer [21] use vision transformers in an encoder-decoder architecture. The encoder transforms pixel patches into latent representations without using any convolutional layers, and the decoder generates the binarized image from the latent representations.

GDB [22] uses gated convolutions that, unlike regular convolutions, precisely extract stroke edges. First, a coarse sub-network generates a precise feature map, and then, a refinement sub-network uses gated convolutions to further refine the feature map. GDBMO is a version of GDB that combines local and global features to further improve the results.

2. Materials and Methods

2.1. Features

The following algorithms were directly used in the proposed solution as features in the model that we trained to predict the optimal global threshold. They operate directly on the image histogram, optimizing various metrics, and can be computed in constant time ($O\left(1\right)$) in relation to the image size. Although some of these algorithms are iterative, they converge rapidly.

Otsu [23] proposed a popular global thresholding algorithm. For a given threshold k, the pixels are divided into two classes: the 0 class, composed of pixels with intensities lower than or equal to k, and the 1 class, composed of pixels with intensities greater than k. Between-class variance is defined as the weighted sum of the variances of the two classes. Otsu’s threshold is defined as the threshold with the largest between-class variance, defined as follows:

$$\begin{array}{c}{\sigma }_{01}^2=W_0\left(t\right)W_1\left(t\right)\left({\mu }_1\left(t\right)-{\mu }_0\left(t\right)\right),\end{array}$$

(5)

where $W_0\left(t\right)$ is the ratio of pixels with intensities lower than or equal to t; $W_1\left(t\right)$ is the ratio of pixels with intensities greater than $t$; and ${\mu }_0,{\mu }_1$ are the mean values of the 0 class and 1 class pixel intensities, respectively.

Kittler and Illingworth [23] proposed a computationally efficient solution for minimum error thresholding. They assumed that the two pixel classes follow normal distributions, splitting the probability density function $p\left(i\right)$ into two components, $p_0\left(i\right)$ and $p_1\left(i\right)$, normally distributed with means ${\mu }_0$ and ${\mu }_1$, standard deviations ${\sigma }_0$ and ${\sigma }_1$, and a priori probabilities $P_0\left(i\right)$ and $P_1\left(i\right)$. They choose a threshold that minimizes the following criterion function:

$$J\left(t\right)=1+2\left(P_0\left(t\right)\log {\sigma }_0\left(t\right)+P_1\left(t\right)\log {\sigma }_1\left(t\right)\right)-2\left(P_0\left(t\right)\log P_0\left(t\right)+P_1\left(t\right)\log P_1\left(t\right)\right)$$

(6)

The function is easy to compute, and finding its minimum is relatively simple, as the function is smooth.

Lloyd [23] proposed an iterative thresholding algorithm that minimizes the mean squared error between the original and the binarized images. In the first iteration, the average intensity is chosen as the threshold, and in further iterations, the threshold is updated via

$$\begin{array}{c}{t}_{i+1}={\displaystyle \frac{{\mathsf{\mu }}_1\left(t_i\right)+{\mathsf{\mu }}_0\left(t_i\right)}{2}}+{\displaystyle \frac{{\mathsf{\sigma }}^2\log \left(W_0\left(t_i\right)/W_1\left(t_i\right)\right)}{{\mathsf{\mu }}_1\left(t_i\right)-{\mathsf{\mu }}_0\left(t_i\right)}},\end{array}$$

(7)

where ${\sigma }^2$ is the variance of the entire image. The algorithm converges when the final threshold is equal to the previous threshold.

Sung et al. [24] argued that the within-class variance is more useful than the between-class variance as a selection criterion for the optimal threshold. The within-class variance is defined as

$$\begin{array}{c}{\sigma }_{0+1}^2=W_0\left(t\right){\mathsf{\sigma }}_0^2\left(t\right)+W_1\left(t\right){\mathsf{\sigma }}_1^2\left(t\right),\end{array}$$

(8)

where ${\sigma }_0^2,{\sigma }_1^2$ are the variances of each class. If there is more than one threshold for which the within-class variance is minimal, then they consider the average of those thresholds to be the optimal one. Their experiments show that their method performs better than Otsu’s on their synthetic dataset.

Ridler and Calvard [23] proposed an iterative thresholding algorithm very similar to Lloyd’s. In the first iteration, the average intensity is chosen as the threshold, and in further iterations, the threshold is updated via

$$\begin{array}{c}{t}_{i+1}={\displaystyle \frac{{\mathsf{\mu }}_0\left(t_i\right)+{\mathsf{\mu }}_1\left(t_i\right)}{2}}.\end{array}$$

(9)

The algorithm converges when the final threshold is equal to the previous threshold.

Huang and Wang [23] proposed an algorithm based on computing a measure of fuzziness, such as Shannon’s entropy, for each possible threshold and choosing the lowest threshold for which the minimum fuzziness is reached. They use the following formula for fuzziness:

$$\begin{array}{c}\mathrm{E}\left(t\right)={\displaystyle \sum _{i=1}^{I_{max}}}S\left({\mathsf{\mu }}_t\left(i\right)\right)h\left(i\right),\end{array}$$

(10)

where $h\left(i\right)$ represents how many times the ith intensity appears in the image,

$$\begin{array}{c}\mathrm{S}\left({\mathsf{\mu }}_t\left(i\right)\right)={\mathsf{\mu }}_t\left(i\right)\ln {\mathsf{\mu }}_t\left(i\right)-\left(1-{\mathsf{\mu }}_t\left(i\right)\right)\ln \left(1-{\mathsf{\mu }}_t\left(i\right)\right)\end{array}$$

(11)

is Shannon’s entropy, and the membership function is

$$\begin{array}{c}{\mu }_t\left(i\right)=\left\{\begin{array}{c}{\left(1+\left|i-{\mu }_0\right|/C\right)}^{-1},\mathrm{i}\mathrm{f}\mathrm{i}\le \mathrm{t}\\ {\left(1+\left|i-{\mu }_1\right|/C\right)}^{-1},otherwise\end{array}\right.\end{array}$$

(12)

where $C$ is a constant value such that $0.5\le {\mu }_t\left(i\right)\le 1$.

Ramesh et al. [23] proposed an algorithm based on functional approximation of the histogram composed of recursive bilevel approximations that minimize an error function. They compare the results of two error functions:

• The sum of the square errors:

$$\begin{array}{c}\mathrm{E}\left(t\right)={\displaystyle \sum _{i=1}^t}{\left(i-{\mathsf{\mu }}_0\right)}^2+{\displaystyle \sum _{i=t+1}^{I_{max}}}{\left(i-{\mathsf{\mu }}_1\right)}^2\end{array}$$

(13)

• The sum of the variances of each class:

$$\begin{array}{c}\mathrm{E}\left(t\right)={\mathsf{\sigma }}_0^2+{\mathsf{\sigma }}_1^2.\end{array}$$

(14)

Their experimental results show that the latter error function produces better results than the former.

Li and Lee [25] proposed an algorithm based on minimizing the cross-entropy between the original image and the binarized image. The cross-entropy is computed for each possible threshold with the following formula:

$$\begin{array}{c}\mathrm{H}\left(t\right)={\displaystyle \sum _{i=1}^{t-1}}i{h}_j\ln {\displaystyle \frac{i}{{\mathsf{\mu }}_0\left(t\right)}}+{\displaystyle \sum _{i=t}^{I_{max}}}i{h}_i\ln {\displaystyle \frac{i}{{\mathsf{\mu }}_1\left(t\right)}},\end{array}$$

(15)

where $h_i$ is the number of pixels with intensity $i$ in the image, and $I_{max}$ is the maximum intensity. Li and Tam [26] proposed an iterative variation of this algorithm, boasting improved computational speed at the cost of accuracy. Brink and Pendock [27] proposed a similar algorithm, but they compute the cross-entropy with the following formula:

$$\begin{array}{c}\mathrm{H}\left(t\right)={\displaystyle \sum _{i=1}^t}{\mathsf{\mu }}_0\left(t\right)\log {\displaystyle \frac{{\mathsf{\mu }}_0\left(t\right)}{i}}+{\displaystyle \sum _{i=t+1}^{I_{max}}}{\mathsf{\mu }}_1\left(t\right)\log {\displaystyle \frac{{\mathsf{\mu }}_1\left(t\right)}{i}}.\end{array}$$

(16)

Kapur et al. [26] proposed an algorithm based on maximizing an evaluation function:

$$\begin{array}{c}\mathrm{f}\left(t\right)={\displaystyle \frac{\mathrm{H}\left(t\right)}{\mathrm{H}\left(I_{max}\right)}}{\displaystyle \frac{\ln c\left(t\right)}{\ln \left(\mathrm{ma}{\mathrm{x}}_{\mathrm{i}=1}^{\mathrm{t}}p\left(i\right)\right)}}+{\displaystyle \frac{1-H\left(t\right)}{H\left(I_{max}\right)}}{\displaystyle \frac{\ln \left(1-c\left(t\right)\right)}{\ln \left(\mathit{ma}{x}_{i=t+1}^{I_{\mathit{max}}}p\left(i\right)\right)}},\end{array}$$

(17)

where they use the classic information entropy formula:

$$\begin{array}{c}\mathrm{H}\left(t\right)=-{\displaystyle \sum _{i=1}^t}p\left(i\right)\ln p\left(i\right)\end{array}$$

(18)

and

$$\begin{array}{c}\mathrm{c}\left(t\right)={\displaystyle \sum _{i=1}^t}p\left(i\right)\end{array}$$

(19)

is the cumulative probability density function.

Sahoo et al. [26] proposed an algorithm based on maximizing the sum of Renyi’s entropies associated with each class:

$$\begin{array}{c}\begin{array}{c}{H}_0^{\mathsf{\alpha }}={\left(1-\mathsf{\alpha }\right)}^{-1}ln{\displaystyle \sum _{i=0}^t}{\left({\displaystyle \frac{p\left(i\right)}{W_0}}\right)}^{\mathsf{\alpha }}\\ H_1^{\mathsf{\alpha }}={\left(1-\mathsf{\alpha }\right)}^{-1}ln{\displaystyle \sum _{i=t+1}^{I_{max}}}{\left({\displaystyle \frac{p\left(i\right)}{W_1}}\right)}^{\mathsf{\alpha }}.\end{array}\end{array}$$

(20)

They observed that there are three distinct thresholds $t_1,t_2,t_3$ that maximize the sum depending on whether α is lower than, equal to, or greater than 1, and use all three values to determine the optimal threshold:

$$\begin{array}{c}\mathrm{t}=t_{\left[1\right]}\left(p\left(t_{\left[1\right]}\right)+0.25\mathsf{\omega }{\mathsf{\beta }}_1\right)+0.25t_{\left[2\right]}\omega {\mathsf{\beta }}_2+t_{\left[3\right]}\left(1-p\left(t_{\left[3\right]}\right)+0.25\mathsf{\omega }{\mathsf{\beta }}_3\right),\end{array}$$

(21)

where $t_{\left[1\right]},t_{\left[2\right]},t_{\left[3\right]}$ are the order statistics of the thresholds $t_1,t_2,t_3$, respectively;

$$\begin{array}{c}\omega =p\left(t_{\left[3\right]}\right)-p\left(t_{\left[1\right]}\right);\end{array}$$

(22)

and ${\beta }_1,{\beta }_2,{\beta }_3$ take different values based on the distances between $t_{\left[1\right]},t_{\left[2\right]},t_{\left[3\right]}$.

Shanbhag [26] proposed a modified version of Kapur’s algorithm. They propose a different information measure:

$$\begin{array}{c}{\mathrm{info}}_0\left(t\right)=\left|{\mathrm{i}\mathrm{n}\mathrm{f}\mathrm{o}}_0\left(\mathrm{t}\right)-{\mathrm{i}\mathrm{n}\mathrm{f}\mathrm{o}}_1\left(\mathrm{t}\right)\right|\end{array}$$

(23)

and choose the threshold that minimizes this measure. They define

$$\begin{array}{c}\begin{array}{c}{\mathrm{i}\mathrm{n}\mathrm{f}\mathrm{o}}_0\left(t\right)=-{\displaystyle \frac{1}{W_0\left(t\right)}}{\displaystyle \sum _{i=1}^t}p\left(i\right)\log P_{0,t}\left(i\right)\\ {\mathrm{i}\mathrm{n}\mathrm{f}\mathrm{o}}_1\left(t\right)=-{\displaystyle \frac{1}{W_1\left(t\right)}}{\displaystyle \sum _{i=t+1}^{I_{max}}}p\left(i\right)\log P_{1,t}\left(i\right),\end{array}\end{array}$$

(24)

where

$$\begin{array}{c}\begin{array}{c}{P}_{0,t}\left(t-i\right)=0.5+{\displaystyle \frac{1}{{2W}_0\left(t\right)}}{\displaystyle \sum _{j=0}^i}p\left(t-i+j\right)\\ P_{1,t}\left(t+i\right)=0.5+{\displaystyle \frac{1}{2W_1\left(t\right)}}{\displaystyle \sum _{j=0}^i}p\left(t+i-j\right).\end{array}\end{array}$$

(25)

Yen et al. [26] proposed a maximum entropy criterion based on the discrepancy between the binarized image and the original image and the number of bits required to represent the binarized image. They define entropy as

$$\begin{array}{c}\mathrm{E}\left(t\right)=-{\displaystyle \sum _{i=1}^t}{\displaystyle \frac{p\left(i\right)\ln p\left(i\right)}{W_0\left(t\right)}}-{\displaystyle \sum _{i=t+1}^{I_{max}}}{\displaystyle \frac{p\left(i\right)\ln p\left(i\right)}{W_1\left(t\right)}}.\end{array}$$

(26)

They choose the threshold with the maximum entropy.

Tsai [26] proposed an algorithm based on preserving the moments of the original image in the binarized image. They use the first 4 raw moments and obtain the following system:

$$\begin{array}{c}\begin{array}{c}\begin{array}{c}{W}_0\left(t\right)+W_1\left(t\right)=m_0\\ W_0\left(t\right)z_0+W_1\left(t\right)z_1=m_1\end{array}\\ \begin{array}{c}{W}_0\left(t\right)z_0^2+W_1\left(t\right)z_1^2=m_2\\ W_0\left(t\right)z_0^3+W_1\left(t\right)z_1^3=m_3,\end{array}\end{array}\end{array}$$

(27)

where $m_i$ is the $i$-th raw moment, and $z_0,z_1$ are representative gray values for the two classes of pixels. Considering that

$$\begin{array}{c}{W}_0\left(t\right)+W_1\left(t\right)=1, \forall t\in \overline{1,I_{max}},\end{array}$$

(28)

solving the system is trivial, and the threshold can be determined from the resulting $W_0\left(t\right)$ as the $W_0\left(t\right)$-th percentile.

Sarle’s bimodality coefficient (BC) [28] uses skewness and kurtosis to ascertain how separable two populations that form a bimodal distribution are. It can also be generalized (GBC) [29] by using standardized moments of higher orders. For both BC and GBC, values range from 0 to 1, with 1 indicating no overlap between the two populations and lower values indicating more overlap. The formula for the $k$-th GBC is

$$\begin{array}{c}{\mathrm{GBC}}_k=\left\{\begin{array}{c}0, for distr. concentrated on one point\\ {\displaystyle \frac{{\tilde{\mathsf{\mu }}}_{2k+1}^2+1}{{\tilde{\mathsf{\mu }}}_{2k+2}{\tilde{\mathsf{\mu }}}_{2k}}}, otherwise\end{array}\right.\end{array}$$

(29)

where ${\tilde{\mu }}_n$ is the $n$-th standardized moment. Sarle’s bimodality coefficient is ${\mathrm{GBC}}_1$.

2.2. Tools

ML.NET [30] is a framework that allows users to train and evaluate a plethora of machine-learning models. Its AutoML component allows users to automatically explore various hyperparameter configurations for said models using one of the several search strategies, such as random search, grid search, and cost frugal tuner (CFT) [31]. There are several model types available in AutoML for regression, but LightGbm [32] always scored best in our tests. LightGbm is a gradient boosting decision tree that uses gradient-based one-sided sampling to exclude a significant proportion of data instances with small gradients, using only the rest to estimate the information gain, and exclusive feature bundling to bundle mutually exclusive features to reduce the number of features.

ML.NET does not allow for custom metrics. The metrics available for regression are the mean squared error (MSE), root mean squared error (RMSE), mean absolute error (MAE), and R-squared (R2), also known as the coefficient of determination [33]. For the first three metrics, values range from 0 to infinity, with 0 indicating a perfect fit. For R2 values range from negative infinity to 1, with 1 indicating a perfect fit. Because MSE and RMSE square the errors, they are more sensitive to larger errors than MAE.

Training a model on a dataset might cause overfitting, i.e., maximizing the performance of the model for the training dataset at the cost of lower performance on new datasets. Resampling the dataset can alleviate or even eliminate overfitting. According to Berrar [34], 10-fold cross-validation is one of the most widely used data resampling methods. k-fold cross-validation splits a dataset into k equally sized disjunct partitions and forms k training sets and k test sets. Each test set consists of one of the k partitions, and its corresponding training set consists of the other k-1 partitions. For each training set, the model is fitted on it and evaluated on its corresponding test set, resulting in k performance metrics, one for each test set, which can be averaged to obtain the performance metric of the model.

Bates et al. [35] introduced nested cross-validation and proved that the method is more robust than cross-validation in many examples. The idea behind nested cross-validation is splitting the dataset into train/test sets twice, fitting the model on the inner train sets and evaluating them on the inner test sets, fitting them on the outer train sets and evaluating them on the outer test sets and then using all the obtained metric on all the test sets to compute a robust approximand for the metric consisting of an average value and an MSE.

2.3. Dataset and Metrics

Our dataset is composed of all the images from the following datasets: the DIBCO datasets [36,37,38,39,40,41,42,43,44,45], a synthetic dataset from [46], the CMATERdb dataset [47], a subset of 10 pages from the Einsielden Stiftsbibliothek [48], a subset of 10 pages from the Salzinnes Antiphonal Manuscript [49], a subset of 15 images from the LiveMemory project [50], the Nabuco dataset [51], the Noisy Office dataset [52], the LRDE-DBD dataset [53], the palm leaf dataset [54], the PHIBD 2012 dataset [55], the Rahul Sharma dataset [56], and a multispectral dataset [57]. To enrich the dataset, 15 variants were generated for each image by adjusting the gamma value with values ranging from 0.5 to 2. For each image, 48 features were computed: the thresholds resulting from the 15 algorithms presented in Section 2.1; the confidence values for the 7 algorithms that provide them, Otsu, Lloyd, Ridler, Huang, Ramesh, Li and Lee, and Li and Tam (which represent the normalized values of their respective optimization functions for their selected thresholds); the normalized between-class variances associated with the computed thresholds; the pixel average, standard deviation, and normalized standardized moments up to the eighth order; Sarle’s bimodality coefficient; and the generalized bimodality coefficients up to the third order. Higher-order moments require significantly better precision than that offered by the standard 64-bit double floating-point representation. In order to ensure the required precision, the Boost Multiprecision C++ library [58] was employed using 256 bits for the cpp_bin_float back-end.

All features were normalized using min-max normalization, which ensures all values are in the $\left[\mathrm{0,1}\right]$ range by subtracting $min$ from all values and then dividing them by $max-min$. The min value was considered 0 for all features that could not have negative values. The max value was considered the maximum possible value for all features with values that, in practice, reach values close to their theoretical upper limit (255 for thresholds, 127.5 for the standard deviation, ${127.5}^2$ for all variances, and 1 for all bimodality coefficients). For the features that do not have a finite or obvious lower/upper limit (both limits for standardized moments of odd orders and upper limits for standardized moments of even orders), quantiles were used instead of min and max values (0.001 quantile for the lower limit, and 0.999 quantile for the upper limit) to clamp outlier values to a more compact interval, ensuring a less sparse distribution of feature values.

A popular metric used to evaluate binarized images is the F-measure (FM), defined as

$$FM={\displaystyle \frac{2TP}{2TP+F}},$$

(30)

where $TP$ is the number of pixels correctly classified as pixels containing text, and $F$ is the number of pixels incorrectly classified. $FM$ takes values between 0 and 1, with 1 indicating a perfect classifier. However, because we are using global thresholding, the maximum value of $FM$ can differ from image to image. The maximum possible value of $FM$ for an image is not necessarily provided by a single threshold. If two thresholds $T_1$ and $T_2$ provide the maximum possible $FM$, then all thresholds in the interval $\overline{T_1,T_2}$ provide the maximum possible $FM$. The ideal threshold of an image, in the global thresholding scenario, was defined as the middle of the largest interval of thresholds that provide the maximum possible FM for that image. The ideal threshold was computed for each image in the dataset and used as the column to be predicted by the ML models.

The goal of the experiment is to find a regression model instance that approximates the ideal threshold as closely as possible. Because the maximum possible FM on different image sets is not necessarily the same, we define the relative FM (${\mathrm{F}\mathrm{M}}_{\mathrm{r}}$) as

$$F{M}_r={\displaystyle \frac{FM}{F{M}_{Max}}},$$

(31)

where $FM$ is the FM provided by the predicted threshold, and ${FM}_{Max}$ is the maximum possible FM of the image. With ${FM}_r$, the performance on different images can be compared as the values it can take are always between 0 and 1, and the maximum value of 1 can always be reached regardless of the image.

Other popular metrics are peak signal-to-noise ratio (PSNR) and MSE. Both PSNR and FM are better when their values are higher, so we define relative PSNR (${\mathrm{P}\mathrm{S}\mathrm{N}\mathrm{R}}_{\mathrm{r}}$) similarly to ${FM}_r$ as

$$PSN{R}_r={\displaystyle \frac{PSNR}{PSN{R}_{Max}}},$$

(32)

where $PSNR$ is the PSNR provided by the predicted threshold, and ${PSNR}_{Max}$ is the maximum possible PSNR of the image. MSE is better when its values are lower, so we define relative MSE (${MSE}_r$) as

$${MSE}_r={\displaystyle \frac{{MSE}_{Min}+ϵ}{MSE+ϵ}},$$

(33)

where $MSE$ is the MSE provided by the predicted threshold; ${MSE}_{Min}$ is the minimum possible MSE of the image, and we add $ϵ$ to avoid division by 0, while still making sure that ${MSE}_r$ can take all values in $\left(\mathrm{0,1}\right]$.

2.4. Proposed Solution

In order to achieve nested cross-validation, the dataset was split into 11 folds, one fold was set apart as the outer test set, and the remaining 10 folds were set as the outer training set. An ML.NET AutoML regression experiment was set up with cross-validation on the outer training set, with a time limit of 60 min, using MSE as the optimizing metric, exploring all the model types available for regression, searching for hyperparameters using an implementation of CFT for hierarchical search spaces. Lower time limits were also tested but produced slightly worse results. Higher time limits were not tested due to increased computational cost. Each of the 10 folds in the outer training set formed an inner test set, with the remaining 9 forming an inner training set. The model instances were fitted on the inner train sets and evaluated on the inner test sets, thus producing 10 different values for the evaluation metrics. The model instances were then refitted on the outer training set and evaluated on the outer test set. Each of the 10 folds was then switched with the one in the outer test set and the model instances were refit on the inner training sets and evaluated on the inner test sets, resulting in a total of 110 different values for the evaluation metrics for models trained on 9 folds and evaluated on one fold and a total of 11 different values for the evaluation metrics for models trained on 10 folds and evaluated on one fold.

We denote ${FM}_r^{in}$ the values for ${FM}_r$ obtained on images from the inner test sets and ${FM}_r^{out}$ the values for ${FM}_r$ obtained on images from the outer test sets. The nested cross-validation estimand of ${FM}_r$ is denoted as $\widehat{{FM}_r}$ and is the average over all the inner test sets of ${FM}_r^{in}$. For each outer test set, two values are computed:

$$\begin{array}{c}{MSE}_{in-out}={\left(\overline{F{M}_r^{in}}-\overline{F{M}_r^{out}}\right)}^2\\ {\mathsf{\sigma }}_{out}^2=variance\left(F{M}_r^{out}\right),\end{array}$$

(34)

where the $\overline{x}$ denotes the average value of the measure $x$, and ${FM}_r^{in}$ refers to all the inner test sets corresponding to the outer test set. The nested cross-validation estimand of the mean squared error of $\widehat{{FM}_r}$ is denoted as $\widehat{{MSE}_{FM}}$ and is the difference between $\overline{{MSE}_{in-out}}$ and $\overline{{\mathsf{\sigma }}_{out}^2}$. Analogous estimands were computed for the PSNR and the MSE of the binarized image but were not used in the ranking of the models.

A score was defined as

$$\widehat{F{M}_r}-3\sqrt{\widehat{MS{E}_{FM}}},$$

(35)

and assigned to each model instance and used to determine the best one (a higher score is better). The best instance was then refit on the whole dataset, and the average metrics were computed over the entire dataset to compare the model’s results with the input algorithms. Algorithm 1 illustrates, using pseudocode, how the best model was selected using NCV.

Algorithm 1. NCV experiment pseudocode.
	Input: dataset
	Output: ML model
1.	partitions = split the dataset into 11 equally sized partitions
2.	for i from 1 to 11
3.	outerFolds[i].testSet = partitions[i]
4.	outerFolds[i].trainSet = all partitions except partitions[i]
5.	innerFolds = split outerFolds [1].trainSet into 10 folds
6.	models = run AutoML 10-fold cross-validation experiment on innerFolds
7.	$\mathrm{bestScore}=-\infty$, bestModel = null
8.	for each model in models
9.	esfm = empty array
10.	for oi from 1 to 11
11.	innerFolds = split outerFolds[oi].trainSet into 10 folds
12.	einfm = empty array
13.	for ii from 1 to 10
14.	trainSet = innerFolds[ii].trainSet
15.	testSet = innerFolds[ii].testSet
16.	innerModel = model.fit(trainSet)
17.	predicted = innerModel.transform(testSet)
18.	for i from 1 to predicted.size
19.	einfm.add(relative FM of predicted[i])
20.	trainSet = outerFolds[oi].trainSet
21.	testSet = outerFolds[oi].testSet
22.	predicted = outerModel.transform(testSet)
23.	eoutfm = empty array
24.	for i from 1 to predicted.size
25.	eoutfm.add(relative FM of predicted[i])
26.	afm[oi] = pow(average(einfm)-average(eoutfm),2)
27.	bfm[oi] = variance(eoutfm)/eoutfm.size
28.	esfm.concatenate(einfm)
29.	$\widehat{MS{E}_{FM}}$= average(afm)-average(bfm)
30.	$\widehat{F{M}_r}$= average(esfm)
31.	$\mathrm{score}=\widehat{F{M}_r}-3\sqrt{\widehat{MS{E}_{FM}}}$
32.	if score > bestScore
33.	bestScore = score
34.	bestModel = model

3. Results

Table 1. NCV results with full feature set.

$\widehat{{\mathit{F}\mathit{M}}_{\mathit{r}}}$(%)	$\widehat{\mathit{M}\mathit{S}{\mathit{E}}_{\mathit{F}\mathit{M}}}$(‰)	$\widehat{{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}_{\mathit{r}}}$(%)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}}$(‰)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{r}}}$(%)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{M}\mathit{S}\mathit{E}}}$(‰)
90.86	7.99	81.64	11.08	62.32	22.01
90.46	8.08	81.16	11.72	61.81	23.69
90.56	8.43	81.11	11.18	61.70	23.86
90.80	8.06	81.40	11.60	61.97	23.97

shows the resulting best model instances of several runs of the same nested cross-validation (NCV) experiment, as described in Section 2.4, using all features. The procedure produces consistent results, with a LightGbm regression model always taking first place.

Three feature subsets were found to impact the results the most: 1—the 15 thresholds, 2—the moments (average, standard deviation, standardized moments from the third to the eighth), and 3—the BCs (Sarle’s bimodality coefficient and the next two generalized bimodality coefficients).

Table 2. Feature subsets.

Feature Set	Thresholds	Moments	BCs
1	+	–	–
2	–	+	–
3	–	–	+
4	+	+	–
5	+	–	+
6	–	+	+
7	+	+	+

+ indicates the presence of a subset and – indicates the absence of a subset.

shows how these subsets were combined, and

Table 3. NCV result comparison.

Feature Set	$\widehat{{\mathit{F}\mathit{M}}_{\mathit{r}}}$ (%)	$\widehat{\mathit{M}\mathit{S}{\mathit{E}}_{\mathit{F}\mathit{M}}}$ (‰)	$\widehat{{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}_{\mathit{r}}}$ (%)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}}$ (‰)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{r}}}$ (%)	$\widehat{{\mathit{M}\mathit{S}\mathit{E}}_{\mathit{M}\mathit{S}\mathit{E}}}$ (‰)
1	89.59	8.64	82.38	7.23	63.05	15.37
2	84.15	8.00	74.79	12.52	50.50	24.45
3	66.88	56.19	66.81	15.50	42.98	25.73
4	90.31	6.93	81.58	10.35	62.28	21.18
5	90.29	8.92	82.97	7.43	64.18	15.59
6	86.42	8.13	77.71	15.28	54.90	27.43
7	90.39	7.96	81.75	10.15	62.52	19.89
Full	90.86	7.99	81.64	11.08	62.32	22.01

compares the NCV results obtained with each subset and with the full set. The results found for the fourth, fifth, and seventh feature subsets are the best out of the seven and in line with the results of the experiments using all features, showing that the discarded features’ contributions are insignificant. Subset 1 seems to be the most relevant, followed closely by subset 2; however, their combinations yield significantly better results.

Table 4. Result comparison on the entire dataset.

Proposed Solution with Feature Set	1	2	3	4	5	6	7	Full
$\overline{FM}$ (%)	81.56	81.65	62.30	81.75	81.73	81.73	81.75	81.55
$\overline{{FM}_r}$ (%)	99.70	99.79	70.58	99.99	99.97	99.93	99.99	99.74
$\overline{PSNR}$	27.01	27.37	18.17	27.50	27.48	27.49	27.50	27.18
$\overline{{PSNR}_r}$ (%)	92.94	93.96	69.22	93.99	93.95	93.96	93.99	93.19
$\overline{MSE}$	3202	3236	8156	3244	3250	3236	3244	3271
$\overline{{MSE}_r}$ (%)	87.50	89.68	70.58	90.60	90.49	90.50	90.60	88.40
Algorithm	Ideal	Otsu	Kittler	Lloyd	Sung	Ridler	Huang	Ramesh
$\overline{FM}$ (%)	81.75	67.11	64.57	63.65	61.68	64.88	53.05	53.67
$\overline{{FM}_r}$ (%)	100	79.24	73.10	70.62	73.40	77.13	64.48	58.90
$\overline{PSNR}$	27.50	15.89	18.45	18.63	15.35	15.12	11.54	14.41
$\overline{{PSNR}_r}$ (%)	93.99	60.21	65.84	67.67	55.40	57.91	46.76	59.54
$\overline{MSE}$	3244	10,289	9528	7900	11,790	10,819	16,322	12,205
$\overline{{MSE}_r}$ (%)	90.6	35.86	45.88	41.01	30.67	33.73	24.22	37.68
Algorithm	Li-Lee	Li-Tam	Brink	Kapur	Sahoo	Shanbhag	Yen	Tsai
$\overline{FM}$ (%)	66.51	68.59	62.34	60.13	59.90	50.22	58.47	60.23
$\overline{{FM}_r}$ (%)	78.86	79.24	73.10	70.62	73.40	77.13	64.48	58.90
$\overline{PSNR}$	16.75	16.94	14.77	13.40	13.20	11.29	12.85	12.04
$\overline{{PSNR}_r}$ (%)	61.04	62.79	65.66	62.35	61.53	51.99	60.35	52.38
$\overline{MSE}$	10,332	9656	6444	9383	9387	10,972	9983	9709
$\overline{{MSE}_r}$ (%)	37.70	39.07	41.21	40.45	39.25	27.60	38.25	25.66

compares the $\overline{FM}$ and $\overline{{FM}_r}$ for each thresholding algorithm and for the ideal threshold, with the results obtained by refitting the models obtained through NCV to the entire dataset. It should be noted that

$${\displaystyle \frac{\overline{FM}}{\overline{F{M}_{max}}}}\ne \overline{F{M}_r}$$

(36)

because even though

$${FM}_r={\displaystyle \frac{FM}{{FM}_{max}}}$$

(37)

averaging ${FM}_r$ produces

$$\overline{{FM}_r}={\mathrm{n}}^{-1}\sum {FM}_r={\mathrm{n}}^{-1}\sum {\displaystyle \frac{FM}{{FM}_{max}}}$$

(38)

and this is different from the average value of $FM$

$$\overline{FM}=n^{-1}\sum FM$$

(39)

because ${FM}_{max}$ is not constant across different images. This is why, in Table 4,

$$\overline{{FM}_r}\ne {\displaystyle \frac{\overline{FM}}{{\overline{FM}}_{IdealT}}}$$

(40)

for any thresholding method other than the ideal one. The observation holds true for PSNR and MSE as well.

Table 5. Average processing time for an image in the dataset.

Feature Set	1	2	3	4	5	6	7	Full
Feature generation runtime (ms)	2	0 *	0 *	2	2	0 *	2	2
ML regression runtime (ms)	230	340	415	225	214	246	251	234
Total image binarization runtime (ms)	232	340	415	227	216	248	253	236

Times marked with 0 * are less than 0.1 ms.

shows the average processing time for an image with a known histogram expressed in milliseconds. The images have an average resolution of 3.31 megapixels. Image resolution does not affect processing times because the proposed solution operates linearly on the image histogram. It should be noted that all the times displayed in this paper were obtained on a machine with an Intel 14600 K processor running at up to 5.3 GHz. The application was built on Windows 11 targeting .NET 6.0.

Table 6. Result comparison on the H-DIBCO 2014 dataset.

Method	$\overline{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}$ (%)	$\overline{\mathit{F}\mathit{M}}$ (%)
Proposed method	19.26	92.8
Elen and Dönmez	19	92.3
Guo and He	18.54	91.2
Guo et al.	19.17	92.3
Mahani et al.	19.16	92.7

compares the results of the proposed method with those of state-of-the-art global thresholding methods (introduced in Section 1.2) on the H-DIBCO 2014 dataset.

Table 7. Result comparison with state-of-the-art methods on all datasets ($\overline{FM}$) versus DIBCO 2019 dataset ${\overline{FM}}_{2019}$.

Method	$\overline{\mathit{F}\mathit{M}}$ (%)	${\overline{\mathit{F}\mathit{M}}}_{2019}$ (%)	$\overline{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}$	${\overline{\mathit{P}\mathit{S}\mathit{N}\mathit{R}}}_{2019}$
Proposed method	83.04	77.71	15.86	16.91
DIBCO winners	88.59	72.88	19.16	14.48
Otsu	76.56	63.87	15.30	12.67
Sauvola	77.66	63.82	15.79	12.66
DeepOtsu	87.04	60.75	19.33	14.44
SAE	88.01	58.78	19.54	12.35
DD-GAN	87.70	58.01	19.87	14.43
MRAM	85.67	49.53	19.18	12.95
2DMN	78.61	42.76	15.55	8.25
cGANs	88.64	62.29	19.66	12.80
DE-GAN	88.52	56.03	19.44	8.37
Suh	89.92	70.63	19.87	14.72
GDB	90.89	73.84	20.41	14.80
GDBMO	91.16	73.50	20.50	14.96
D2BFormer	91.73	66.69	20.83	15.05
DocDiff	-	73.38	-	15.14
DocEnTr	-	59.00	-	13.85
DocBinFormer	92.22	60.31	21.30	14.49

shows that the proposed method outperforms state-of-the-art neural-network-based methods (introduced in Section 1.2) on the DIBCO 2019 dataset, but it also shows that, when averaging on all DIBCO datasets, the proposed method cannot compete. This shows that global methods are not obsolete and that local methods are not always the better choice, even when time and resources are not taken into consideration.

4. Discussion

One thing to note is that the proposed solution’s global approach offers various benefits in terms of robustness and computational efficiency. By operating in a global context, rather than depending on local relationships, the algorithm is less affected by noise or small-scale variations that could affect the results, making it especially useful for tasks where global patterns matter more than detailed local structures. This also results in simpler computations, meaning faster processing and lower complexity, which is ideal for real-time or resource-constrained applications, like embedded systems. Additionally, since the solution does not depend on spatial relationships between samples, it generalizes well to various signals that require separation in low- and high-value groups, beyond just bi-dimensional images. The efficiency also benefits OCR systems and other machine learning applications, where local approaches can introduce noise by providing reliable preprocessing and robust features that can be computed quickly and efficiently.

However, while this approach of ignoring local relationships enhances efficiency, it can lead to the loss of important local information, which could be crucial for tasks like edge detection, texture analysis, or applications where neighboring samples are strongly correlated. For such scenarios, methods that take local relationships into account might provide more accurate results.

In the following figures, black represents true positives, white represents true negatives, cyan represents false positives, and red represents false negatives. Figure 1 illustrates the importance of local relationships with two images from the DIBCO 2018 dataset for which global binarization algorithms cannot possibly achieve an acceptable result. For images such as these, there is no global threshold with which you can eliminate both false negatives and false positives.

Figure 2 shows that on some images, such as image 13 from the challenging DIBCO 2019 dataset, where even state-of-the-art neural-network-based algorithms struggle to produce acceptable results, a global binarization algorithm can produce competitive results.

The diverse training dataset produces a model that is more robust in terms of noise, illumination conditions, contrast, etc. Combining multiple datasets carries the risk of hindering model performance for some particular datasets, but the benefit of increasing the robustness outweighs the risk. Cross-validation further reduces this risk, ensuring that the model performs consistently across all folds.

Data augmentation also improves model robustness and performance. The parameters used for all data augmentation transformations were set to produce realistic results that could have been captured from the same documents in different lighting conditions or with different camera settings.

5. Conclusions

The proposed solution produces results very close to the ideal scenario on various datasets and much better than any of the input algorithms, with an average score of around 90.3–90.8% of the maximum possible score and an MSE of around 0.7–0.8% when using nested cross-validation. When refitting the models on the entire dataset, the results improved even further, with the best model reaching an average score of 99.99% of the maximum possible score and an average processing time of just 0.22–0.25 s.

Future improvements could include using FM as the optimization metric, which might boost the average score and MSE across dataset folds, although this was not feasible in the current implementation due to the limitations of the ML.NET framework. The overall accuracy could be enhanced by applying the algorithm locally around each pixel, resulting in a local thresholding algorithm, or by applying the model on image patches, resulting in a mixed global–local thresholding algorithm. Experimenting with different neural network architectures specialized for regression instead of using AutoML might yield better results.

The proposed solution could be used as an estimator in a more complex approach. For example, Yang et al. [22] use Otsu’s method to generate an input noisy mask for a multi-branch coarse sub-network that predicts an output mask, which then feeds into a refinement sub-network to produce the final binarized image. The predicted ideal threshold could also be used as a feature in a local thresholding machine learning model.

Additional algorithms could be implemented into the overall solution to improve performance and adaptability to more complex tasks. For instance, incorporating local or mixed global–local thresholding techniques could improve accuracy in cases where fine-grained details are crucial. By expanding the algorithm to include more advanced techniques, the solution could become even more robust, offering greater flexibility for tasks such as image segmentation, edge detection, or other specialized applications.