Introduction

Visual texture classification is a challenging task in the field of pattern recognition, image processing, and computer vision. It is also a popular research topic during the past decades due to its applications such as face description and detection [1, 2], medical image analysis and understanding [3, 4], material analysis and classification [5], remote sensing [6, 7], and so on.

Feature descriptor and classifier designation are two key sub-problems for visual texture classification. As elaborated in [8], feature descriptors play a more critical role in texture classification. Several texture feature descriptors were proposed to explore effective texture representation. In many cases, high quality and robustness of texture representation are of considerable importance in texture analysis. It is an intriguing issue to extract the completed representation information of texture classes as far as possible.

Binary pattern family methods have demonstrated tremendous success in texture analysis due to their excellent performance. As one of the most prominent texture descriptors, local binary pattern (LBP) methods were firstly introduced in [9] by Ojala et al. The basic idea of LBP is to extract local texture feature by encoding the sign of the difference vector. It has a lot of outstanding advantages, such as rotation invariance, robustness to illumination changes, ease of implementation, and no need for pre-training. Motivated by Ojala’s [9] work in 2002, many LBP variants have been developed to be applied in diverse range of problems, such as texture classification [10], content-based image retrieval [11, 12], face recognition [13,14,15], medical image analysis [3, 4, 16], and object recognition [17]. In particular, Guo et al. [18] proposed the completed modeling of LBP operator for texture classification, named completed local binary pattern (CLBP). The main idea of CLBP is to represent the local region by three components: the sign of difference vector, the magnitude of difference vector, and the center pixel. It combines the three operators for completed texture representation in joint and hybrid ways. For robustness to noise, Tan et al. [15] introduced local ternary patterns (LTP) for practical face recognition systems, which quantized and encoded the local difference into three levels. The experiments showed that it was more discriminative and less sensitive to noise than the original LBP. Others tried to explore some new ideas for texture representation. For example, Guo et al. [19] developed the local binary pattern variance (LBPV) to explore the local contrast information based on the variance weight. And Y. Zhao et al. [20] presented local binary count (CLBC) for rotation invariant texture classification, which abandoned the local binary structural information and extracted the local binary grayscale difference information directly. Although this method can represent the local texture effectively, it cannot express the visual microstructure. In addition, Zhao et al. [21] introduced a robust LBP framework named as completed robust local binary pattern (CRLBP) by replacing the center pixel by the average local gray level.

More recently, Song et al. [22] presented a simple and robust texture descriptor named adjacent evaluation local binary pattern (AELBP) for texture classification, which used an adjacent evaluation window to develop the threshold scheme. Guo et al. [23] proposed the scale selective LBP (SSLBP) to address scale variation for texture classification. R. Mehta et al. [24] developed a rotation-invariant and computationally efficient dominant rotated local binary pattern (DRLBP) and increased the discriminative power by discarding the redundant patterns. Pan et al. [25] introduced a feature-based local binary pattern (FbLBP). For FbLBP, the difference magnitude was described by mean and variance. And an adaptive local threshold was developed to encode the two features into binary codes. Wang et al. [26] proposed a discriminative and robust descriptor—local binary circumferential and radial derivative pattern (CRDP)—by fusing both local circumferential and radial derivative features. By extending the non-uniform patterns mapping technique, M. Shakoor et al. [27] presented the extended mapping local binary pattern (EMLBP) method for texture classification. In order to handle the complex local patterns, Z. Zhang et al. [28] developed an information-theoretic framework, namely completed discriminative local features (CDLF), which can learn completed discriminative local features for better representation of texture images.

In recent years, there has been an increased interest in deep features for image representation. And they have achieved significant performance improvement in various fields, especially visual feature extraction [29,30,31,32], such as image classification and retrieval [33,34,35,36,37,38], object recognition and detection [39, 40], place recognition [41, 42], human pose recovery [43, 44], shape recognition [45], emotion recognition [46}, etc. The key to successful CNNs is that they can learn high-quality features from lots of annotated training data. However, the main drawbacks of CNNs applied in visual texture classification are the limited labeled training data. In addition, most deep learning methods have difficulties concerning the high computational complexity and parameters tuning [47]. In 2017, Huang et al. [48] indicated that a structured and robust local descriptor can bring additional benefits to CNNs. Especially for texture classification, some classical methods can be successful complementary solutions to deep learning.

Great efforts have been contributed to satisfy the demands of discriminative and robust texture representation. However, there still remain some inborn defects of LBP. For instance, most of LBP variants were sensitive to noise. They lose local or global texture information. Lots of LBP variants used the simple pixel-level information to explore the local pattern, and the simple and direct representation was difficult to extract some deep abstract texture information effectively. So how to describe different local texture information and how to extract the information are the two fundamental issues for comprehensive understanding and representing the real-world textures.

In this paper, we aim to extract comprehensive and robust texture information. For keeping the simplicity and effectiveness of the original CLBP and addressing its weakness, we propose an efficient completed local entropy binary pattern descriptor and extend it by using the multiscale hierarchical threshold. The proposed methods have two advantages: (1) As it will be shown further, the multiscale hierarchical threshold easily incorporates the different scale texture information by hierarchical adaptive local partition, which makes the local binary more effectively. (2) The entropy binary pattern can reflect the spatial distribution characteristics between the center pixel and neighbor pixels effective, which is complementary to the original CLBP descriptors. The main contributions of this paper include the following:

  1. 1.

    We introduce a multiscale thresholding scheme based on hierarchical adaptive local partition, which provides different scale texture information to help the optimization of the binary coding.

  2. 2.

    We propose an efficient completed local entropy binary pattern descriptor. As a statistical measure of randomness, the local entropy binary pattern can be used to characterize the spatial distribution between the center pixel and neighbor pixels.

  3. 3.

    We extend the CLEBP by using the multiscale hierarchical threshold to achieve a comprehensive understanding and representation, which can be more robust, discriminative, and comprehensive.

  4. 4.

    Extensive experimental evaluation on three representative texture datasets (Outex, UIUC, and KTH-TIPS) is conducted, showing that the proposed methods demonstrate superior performance to the classical LBP variants and recent state-of-the-art texture descriptors.

The rest of the paper is organized as follows. Section 2 discusses the related work. In Section 3, we introduce novel multiscale thresholding. Then, we produce a novel completed local entropy binary pattern descriptor and extend it by using the multiscale thresholding. Experimental results of our proposed methods are presented in Section 4. Finally, Section 5 concludes the paper.

Related Work

Local Binary Pattern

Ojala et al. [9] proposed the LBP operator for texture analysis, which combined structural and statistical texture information by taking the difference of the center pixel with respect to its neighbors. In general, as illustrated in Fig. 1, the classical LBP operator can be defined as below:

$$ LB{P}_{P,R}=\sum \limits_{p=0}^{P-1}s\left({g}_p-{g}_c\right){2}^p,s(x)=\Big\{{\displaystyle \begin{array}{c}1,x\ge 0\\ {}0,x<0\end{array}}, $$
(1)

where gc and gp represent the gray value of the center pixel and circularly symmetric neighborhood pixels, respectively. P is the total number of the neighborhood pixels on a circle of R(R > 0). s() is the sign function. Figure 1 shows the standard pipeline of the LBP operator (P = 8), including the original pattern, binary pattern, and the weights corresponding to these neighbors. If the coordinates of gc are (a, b), then the coordinates of neighborhood pixels gp can be given by (a − R sin(2πp/P), b + R cos(2πp/P)) for p = 0, 1, …, P − 1. It is worth noting when the neighbor point does not fall at integer coordinates, we can compute its value by interpolation.

Fig. 1
figure 1

The standard pipeline of LBP operator

Full size image

In order to enhance the robustness to the rotation, the rotation invariant LBP is proposed by formula (2):

$$ LB{P}_{P,R}^{ri}=\min \left\{ ROR\left( LB{P}_{P,R},i\right)|i=0,1,\dots, P-1\right\}, $$
(2)

where ROR(x, i) represents an i-step circular bit-wise right shift on x. \( LB{P}_{P,R}^{ri} \) has a crude quantization for occurrence statistics of rotation invariant patterns, leading to a dramatic reduction in feature dimensionality.

Furthermore, Ojala et al. [9] proposed a uniform rotation invariant texture descriptor \( LB{P}_{P,R}^{riu2} \):

$$ LB{P}_{P,R}^{riu2}=\Big\{{\displaystyle \begin{array}{c}\sum \limits_{p=0}^{P-1}s\left({g}_p-{g}_c\right)\kern1em \mathrm{if}\ U\left( LB{P}_{P,R}\right)\le 2\\ {}P+1\kern7.5em \mathrm{otherwise}\end{array}}, $$
(3)

where

$$ {\displaystyle \begin{array}{c}U\left( LB{P}_{P,R}\right)=\mid s\left({g}_{p-1}-{g}_c\right)-s\left({g}_0-{g}_c\right)\mid +\\ {}\kern0.5em \sum \limits_{p=1}^{P-1}\mid s\left({g}_p-{g}_c\right)-s\left({g}_{p-1}-{g}_c\right)\mid, \end{array}} $$
(4)

where the superscript riu2 represents the rotation-invariant uniform patterns, which has P + 2 distinct output values.

In general, the histogram of LBP operator outputs is regarded as the final feature vector. And it is a very powerful tool for texture classification.

Completed Local Binary Pattern

Using the local difference sign-magnitude transform (LDSMT) and the center pixel intensity, Guo et al. proposed CLBP [18], which introduced the three local features including the center gray level (C), the sign (S), and the magnitude (M). Then, as illustrated in Fig. 2, the three operators, named CLBP_Center (CLBP_C), CLBP_Sign (CLBP_S), and CLBP_Magnitude (CLBP_M), were proposed to improve the discriminative capability and complementary information.

Fig. 2
figure 2

The standard pipeline of CLBP operator

Full size image

The CLBP_C is computed by the difference between the center pixel and the average gray level of the whole image. It is defined as

$$ CLBP\_{C}_{P,R}=t\left({g}_c,{c}_I\right),\kern0.5em t\left(x,c\right)=\Big\{{\displaystyle \begin{array}{c}1,\kern0.5em x\ge c\\ {}0,\kern0.5em x<c\end{array}}, $$
(5)

where the threshold cI is set as the average gray level of the whole image. And t(·) is the threshold function.

The CLBP_S is equivalent to the classical LBP operator defined in (1).

The CLBP_M is the magnitude LBP operator described as follows:

$$ CLBP\_{M}_{P,R}=\sum \limits_{p=0}^{P-1}t\left({m}_p,{c}_m\right){2}^p,\kern0.5em {m}_p=\mid {g}_p-{g}_c\mid, $$
(6)

where t(·) is defined in (5). gp and gc are defined in (1). The threshold cm is the mean value of mp for the whole image.

As elaborated in [18], there are two ways to combine the CLBP_C, CLBP_S, and CLBP_M for improving the classification results, including jointly and hybridly. Then, we can get different feature combinations, such as CLBP_M/C, CLBP_S/M, CLBP_S_M/C, and CLBP_S/M/C. By analyzing the occurrence of combined histograms among different texture classes, the texture classification can be realized more exactly.

The main contribution of literature [18] is that it decomposed local difference into two complementary components: the signs and the magnitudes, which can capture more texture information on pixel level than the traditional LBP. As a matter of fact, all the features of CLBP are based on the pixels directly, it cannot represent the abstract and deep information. Noticeably, the CLBP cannot supply the completed texture information, so the completeness and accuracy cannot be guaranteed.

The Multiscale Hierarchical Threshold-Based Completed Local Entropy Binary Pattern

The Multiscale Hierarchical Threshold

In the conventional LBP and CLBP operators, the thresholds used for local binary encode are limited to single scale information (such as the central pixel value for the conventional LBP operator and the average gray level of the whole image for the CLBP operator). However, they were not reasonable to capture and express texture information accurately and appropriately. Intuitively, as texture is a spatial phenomenon, texture representation should not be based on a single pixel but requires the analysis of pixel information over the local region. In order to solve the aforementioned difficulties, in this section, we propose a robust multiscale thresholding framework based on hierarchical adaptive local partition. The framework incorporates different scale texture information and overcomes the shortcoming of traditional thresholding.

Aiming at finding a threshold which contains multiscale information to encode the local binary pattern, in this study, we design a simple and robust multiscale thresholding framework based on hierarchical adaptive local partition. Figure 3 shows an illustrative example of the proposed multiscale hierarchical threshold (scale N = 3). Firstly, given a texture image, a preprocessing step is derived by standardization. Secondly, for each texture image, a multiscale hierarchical grid partitioning is built according to the value of N. Then, we calculate the mean of each grid block as hierarchical threshold based on multiscale grid partitioning. Finally, we average over all hierarchical thresholds as the multiscale threshold. The proposed multiscale hierarchical threshold framework extracts multiscale texture information from different hierarchical partitions, so it can capture more comprehensive and discriminative information for texture information encoding.

Fig. 3
figure 3

An illustration of multiscale thresholding (taking N = 3 as an example)

Full size image

In order to give a compact mathematical formulation of the proposed multiscale thresholding framework, we define the multiscale thresholding as follows:

$$ thr{e}_{N,{g}_{i,j}}=\frac{1}{N}\sum \limits_{k=1}^Nl{m}_k\left({g}_{i,j}\right), $$
(7)

where gi, j is the gray pixel of the pixel in the coordinates (i, j). And \( thr{e}_{N,{g}_{i,j}} \) represents the multiscale thresholding in the coordinates (i, j) with scale N. lmk(gi, j) denotes the local mean of gi, j based on grid partitioning in scale k. k ∈ [1, N] is the multiscale grid partitioning parameter, and N is the total number of the multiscale hierarchical partitioning.

Taking N = 3 as an example, Fig. 3 provides an illustration to explain the proposed multiscale hierarchical threshold. As shown in Fig. 3, the multiscale hierarchical threshold framework contains more comprehensive and robust texture information than traditional thresholding obviously. Note that, when N = 1, the multiscale thresholding framework is equivalent to the threshold settings in traditional CLBP.

In this paper, a set of experiments were conducted in the texture database (Outex_TC_00010) to select the optimal parameter N, which will be discussed later in Section 4.2.

The Local Entropy Binary Pattern

As we all know, how to extract full discriminative texture information is an important task for texture classification. However, in the conventional CLBP operators, the three local features (CLBP_C, CLBP_S, and CLBP_M) are directly extracted based on pixel original values. Intuitively, they are too humdrum to present comprehensive and robust texture information. Particularly, with respect to CLBP_C, it has two kinds of values and contains only one bit. Actually, it is not enough to build the local pattern for texture classification.

In order to overcome the aforementioned difficulties, we propose an efficient local entropy binary pattern (LEBP) by introducing the image entropy, which plays an auxiliary role to supply complementary texture information for CLBP_C. Image entropy characterizes textures by the statistical measure of randomness characteristics, which reflects how much information in an image. The more random the values of pixels in a region are, the higher the entropy of the region will be. It is constructed based on the image histogram. So, in this section, we use the image entropy to evaluate the stability of the image. In this section, we use the two-dimensional image entropy to build the local entropy binary pattern, which reflects the spatial characteristic of grayscale distribution.

In the definition of two-dimensional image entropy, the neighborhood pixel gray mean and grayscale of pixel make up two-tuples spatial characteristics.

The two-tuples is set as (g, m), which expresses the comprehensive features with respect to the value of the pixel and the neighborhood pixel gray mean, where g(0 ≤ g ≤ 255) is the value of the pixel and m(0 ≤ m ≤ 255) is the neighborhood pixel gray mean. We represent the frequency of occurrence for two-tuples spatial characteristics as f(g, m), and it describes the comprehensive gray-value distribution features between a pixel and its neighbors. The two-dimensional image entropy is defined as

$$ {p}_{g,m}=\frac{f\left(g,m\right)}{D^2} $$
(8)
$$ E{N}_{g,m}=-\sum \limits_{m=0}^{255}\sum \limits_{g=0}^{255}{p}_{g,m}\ln {p}_{g,m}, $$
(9)

where D is the dimensions of the given texture image.

We perform the LEBP encoding based on the local region two-dimensional image entropy. Similar to the CLBP_C, the LEBP is developed by the difference between the two-dimensional image entropy of center local region, and multiscale entropy thresholding. Formally, the LEBP is built by

$$ LEBP=t\left(E{N}_c, thr{e}_{N,E{N}_c}\right), $$
(10)

where t(·) is defined in (5). ENc is two-dimensional image entropy of center local region and \( thr{e}_{N,E{N}_c} \) devotes the multiscale entropy thresholding corresponding to the center local region. Figure 4 illustrates the operation of LEBP on a given image. LEBP encodes the local two-dimensional image entropy, which is more abstract to express the texture information than the pixel original values. So, it can supply more complementary information for CLBP_C.

Fig. 4
figure 4

An illustration of CLEBP operator

Full size image

The Multiscale Hierarchical Threshold Completed Local Entropy Binary Pattern

In order to overcome the inherent limitations of CLBP, we propose the CLEBP descriptor by combining LEBP to represent the comprehensive and robust texture information. Meanwhile, we extend it based on the multiscale hierarchical threshold framework to enhance the performance of texture descriptor. For the sake of convenience in writing, we abbreviate the completed local entropy binary pattern based on multiscale thresholding as CLEBP. As shown in Fig. 4, the CLEBP contains four components: the central pixel component (CLEBP_C), the local entropy component (CLEBP_E), the sign component (CLEBP_S), and the magnitude component (CLEBP_M).

The CLEBP_C is defined as follows:

$$ CLEBP\_{C}_{P,R}=t\left(\phi \left({g}_c\right), thr{e}_{N,{g}_c}\right) $$
(11)
$$ \phi \left({g}_c\right)=\frac{1}{M}\sum \limits_{q=1}^M{g}_q, $$
(12)

ϕ(gc) is gc − centric local square region operator, which can improve the robustness of the descriptor and show better performance. M is the number of local square region pixels, and gq denotes the gray value of each pixel in the local square region. gc represents the center pixel. \( thr{e}_{N,{g}_c} \) denotes the multiscale thresholding of the center pixel, and N is the total number of the multiscale hierarchical partitioning.

CLEBP_E is defined in (10).

CLEBP_S is generated as follows:

$$ CLEBP\_{S}_{P,R}=\sum \limits_{p=0}^{P-1}s\left(\phi \left({g}_p\right)-\phi \left({g}_c\right)\right){2}^p, $$
(13)

where ϕ(·) is defined in (12). gp and gc are defined in (1).

It is worth noting that the CLEBP_S does not use the multiscale thresholding to encode the local sign component. The main reasons are as follow: On one hand, as elaborated in [18], the sign component is more informative to represent the original local difference. For texture description, there is no doubt that the microstructure texture information is more important than the macrostructure one, even if we hope for more comprehensive information. On the other hand, from a viewpoint of multiscale information, we hope the new operators contain multiscale texture information, so we apply the sign component to represent the pixel-level texture details. Then, the CLEBP_S keeps the micro thresholding scheme.

CLEBP_M can be computed as

$$ CLEBP\_{M}_{P,R}=\sum \limits_{p=0}^{P-1}t\left(\phi \left({m}_p\right), thr{e}_{N,{m}_p}\right){2}^p, $$
(14)

where ϕ(·) is defined in (12). t(·) is defined in (5). \( thr{e}_{N,{m}_p} \) denotes the multiscale thresholding of mp, and N is the total number of the multiscale hierarchical partitioning.

As elaborated in [8], there are two ways to combine four local binary patterns CLEBP_C, CLEBP_E, CLEBP_S, and CLEBP_M for texture classification, including concatenation and jointly. In this paper, two fusion features are used to the following experimental evaluation, which are represented as “CLEBP _S_M/C/E” and “CLEBP_S/M/C/E”. Then, we extend them by the multiscale hierarchical threshold, abbreviated as “CLEBP_S_Mth/Cth/Eth” and “CLEBP_S/Mth/Cth/Eth”. By analyzing the occurrence of combined histograms among different texture classes, the texture classification can be realized more exactly. It has been shown that approaches based on joint distributions can achieve better results for texture classification.

Dissimilarity Metric

In this study, we use the nearest neighborhood classifier (NNC) to test the performance of our proposed descriptor for texture classification. There are various distance metrics to evaluate the goodness-of-fit, including chi-square, histogram intersection, log-likelihood, cosine distance, etc.

In this paper, we utilize the chi-square distances as the dissimilarity between the testing samples and the training samples. Then, the chi-square distance could be calculated as follows:

$$ D\left(T,M\right)=\sum \limits_{h=1}^H\frac{{\left({T}_h-{M}_h\right)}^2}{T_h+{M}_h}, $$
(15)

where H is the number of bins and Th and Mh correspond to the values of the testing sampling and the training sampling at the hth bin respectively.

Experimental Evaluation

In this section, we validate the effectiveness of the proposed CLEBP descriptor and multiscale thresholding framework with comprehensive experiments on three large and representative databases: the Outex database [49], UIUC database [50], and KTH-TIPS database [51]. We describe the details in the following section and summarized in Table 1. In addition, the proposed CLEBP descriptor is compared with most of the state-of-the-art texture descriptors for texture classification.

Table 1 Summary of texture database used in experiments Θ1 = {5o, 10o, 15o, 30o, 45o, 60o, 75o, 90o},Θ2 = {0o, 5o, 10o, 15o, 30o, 45o, 60o, 75o, 90o}
Full size table

The Image Databases and Experimental Setup

We demonstrate the performance of CLEBP descriptor on three large and representative databases. The texture image databases used in this section are introduced below.

The Outex database [34] collects a large number of surface textures and natural scenes, which provides a rich foundation for processing the variations of illumination/rotation/ resolution. The Outex database also provides a series of test suits by varying different parameters of the experimental design for empirical evaluation of texture classification. In this section, we use the Outex test suits including Outex_TC_0010 (Outex_TC10) and Outex_TC_0012 (Outex_TC12), which contain 24 different homogeneous texture classes (shown in Fig. 5) with dimensions of 128 × 128. The Outex_TC10 and Outex_TC12 were captured under three illuminations (“inca,” “t184,” and “horizon”) and nine rotation angles (0°, 5°, 10°, 15°, 30°, 45°, 60°, 75°, and 90°).

Fig. 5
figure 5

The 24 textures classes from the Outex database

Full size image

The UIUC texture database [35] has 25 classes of images with 40 samples, which was captured under significant viewpoint changes and scale variations. And all images are in grayscale JPG format, 640 × 480 pixels, which contains non-planarity of the textured surface (bark), significant non-rigid deformations between different samples of the same class (fur, fabric, and water), in-homogeneities of the texture pattern (bark, wood, and marble), and viewpoint-dependent appearance variations (glass). The result on UIUC database is reported as the mean classification accuracy over 50 random splits into training and testing dataset, wherein each texture class, Nt (Nt = 20, 15, 10, 5) images are used for training and the remaining 40-Nt images are used as the test set. Figure 6 shows the samples of 25 texture classes on UIUC database.

Fig. 6
figure 6

The 25 textures classes from the UIUC database

Full size image

The KTH-TIPS database [36] includes 10 texture classes captured in the real-world textures under different conditions. There are 81 images (200 × 200) per class. The variety of textures present in the database is shown in Fig. 7. In this paper, 40, 20, 10, and 5 images of each texture class are utilized for training and the remaining images are used for testing.

Fig. 7
figure 7

The 10 textures classes from the KTH-TIPS database

Full size image

Experimental Results on Outex Database

Testing the Performance of the Proposed Multiscale Hierarchical Threshold Framework

In order to evaluate the performance of the proposed multiscale hierarchical threshold framework and give reasonable parameters settings, we carried out some experiments on Outex database, and more precisely on the text suit: Outex_TC_00010 (TC10).

For the purpose of removing the impact of feature extraction, we use the CLBP operator, which was published in [18], to verify the effectiveness of multiscale thresholding framework. It is worth reminding that we do not use the multiscale thresholding to encode the local sign component. The magnitude component and center pixel are encoded by the multiscale thresholding framework. In this experiment, we set the number of layers (N in (7)) for multiscale hierarchical partitioning from 1 to 5. We evaluate the parameters settings at a single scale (P, R) = (8, 1).

Figure 8 shows the classification results with a different number of thresholding layers visually. We can get the following finding from Fig. 8 that most operators significantly improve the best results with four thresholding layers on TC10, expect for CLBP_M. For example, the CLBP_S/M/C obtains the best classification rate (98.20%) with four thresholding layers, and CLBP_M/C, CLBP_S/M, and CLBP_S_M/C reach the classification rates of 93.02%, 95.13%, and 95.99%, respectively. And then, as the number of thresholding layers increases, the classification rate will remain stable or even decrease. According to the results, in order to enhance both the discriminative power and computational efficiency, we limit the multiscale thresholding framework evaluation to three thresholding layers in the following experiments on Outex database. Secondly, the experimental results indicate that the increasement of the number of layers is not always helpful for the improvement of classification performance. On the contrary, when the number of thresholding layers exceeds four, the classification performance would degrade. Obviously, the number of thresholding layers is a fine-tuned parameter which depends on different texture databases.

Fig. 8
figure 8

The classification results with different number of thresholding layers for CLBP operator

Full size image

Experimental Results on the Outex Database

To fully evaluate the capabilities of the proposed CLEBP with multiscale threshold, some classical texture descriptors and state-of-the-art methods are adopted as the competitors. Table 2 details experimental results compared with the traditional LBP, original CLBP, some classical LBP variants, and recent state-of-the-art methods at a different scale.

Table 2 Classification rate (%) on Outex_TC10 and Outex_TC12
Full size table

Through Table 2, we can draw some interesting conclusions. The proposed multiscale thresholding framework is helpful for the improvement of classification accuracy. As can be seen, on TC10, the CLEBP_S/Mth/Cth/Eth is higher than CLBP_S/M/C by about 1.14%, 0.52%, and 0.42% with (P, R) = (8, 1), (16, 2), and (24, 3), respectively. For TC12_000, the improvement in accuracy between CLEBP_S/Mth/Cth/Eth and CLBP_S/M/C are 2.04%, 1.48%, and 1.34% with corresponding (P, R) = (8, 1), (16, 2), and (24, 3), respectively. For TC12_001, we can draw similar conclusions. Derived from the differences, we can conclude that the CLEBP_S/Mth/Cth/Eth performs better than corresponding CLBP_S/M/C. The proposed multiscale thresholding framework is very discriminative and powerful, which helps the optimization of binary coding.

The proposed CLEBP method outperforms classical LBP variants and the state-of-the-art methods in Table 2. Firstly, we can see that the proposed CLEBP method, especially for CLEBP_S/Mth/Cth/Eth, is the best in comparison with LBP and CLBP. For example, with (P, R) = (24, 3), the CLEBP_S/Mth/Cth/Eth operator obtains the best classification accuracy of 99.87% on TC10, which has 4.8% and 0.94% improvement compared with the classification rate of LBP and CLBP_S/M/C, respectively. Similarly, with the same scale, the CLEBP_S/Mth/Cth/Eth operator also reaches the best result (98.03% and 97.92%) on TC12_000 and TC12_001, which maintains the great advantage of 12.99% and 17.14% over LBP, and shows a performance boost of 2.71% and 3.39% over CLBP_S/M/C, respectively. In addition, the classification rate by CLEBP_S/Mth/Cth/Eth gets to 99.58% on TC10 with (P, R) = (8, 1), 3.02% higher than the CLBP_S/M/C operator, and even 14.77% better than the accuracy of traditional LBP. With the same scale on TC12_000, CLEBP_S/Mth/Cth/Eth has significant 29.33% and 4.49% improvement over the accuracy of the original LBP and CLBP_S/M/C respectively. Similarly, on TC12_001, it maintains the obvious advantage of 31.25% and 2.54% over LBP and CLBP_S/M/C, respectively. Similar conclusions can be obtained with (P, R) = (16, 2).

Secondly, the CLEBP_S/Mth/Cth/Eth operator outperforms some classical LBP variants. For example, on TC10 with (P, R) = (8, 1), CLEBP_S/Mth/Cth/Eth achieves the best accuracy of 99.58%, which has about 2.42%, 2.03%, and 2% improvements over CLBC, CRLBP (α = 8), and AECLBP_S/M/C, respectively, and even 7.71% higher than the accuracy by BRINT.

Thirdly, compared with recent state-of-the-art approaches, similar conclusions can be made from the experimental results. More specifically, the proposed CLEBP_S/Mth/Cth/Eth reaches the classification rate of 99.58% on TC10 with (P, R) = (8, 1), also maintaining the distinct advantage of 11.04%, 1.78%, 2.13%, and 0.73% over DRLBP3, LQC_C(6)N(4), CDLF_S/M/C_AHA, and FbLBP, respectively. Likewise, for TC12_000 and TC12_001, we can reach similar conclusions. In addition, these groups of comparisons imply that the proposed CLEBP_S/Mth/Cth/Eth outperforms the recent state-of-the-art methods on the Outex database and has a more comprehensive understanding and representation for texture information.

It is noteworthy that the computational cost of CLEBP_S/Mth/Cth/Eth is 0.060 s for a texture image on TC10, which is about twice as much as the CLBP_S/M/C descriptor (0.032 s). There is no doubt that the operation of multiscale thresholding framework and local entropy binary pattern increase the expense in computational cost. However, the proposed CLEBP_S/Mth/Cth/Eth still has the same order of magnitudes for computational time as CLBP_S/M/C. The additional computational cost does not affect the effectiveness of the algorithm too much. Moreover, it is worthwhile that the CLEBP_S/Mth/Cth/Eth uses the additional computational cost in return for the improvement of accuracy. As a result, The CLEBP_S/Mth/Cth/Eth operator obtains the best classification accuracy of 99.58% on TC10 with (P, R) = (8, 1), which has about 3.02% improvement over the CLBP_S/M/C descriptor.

Experimental Results on the UIUC Database

Table 3 compares classification results between different methods on UIUC database. It can be observed that the proposed multiscale thresholding strategy significantly enhances the classification performance of the texture descriptors. Through analyzing the classification performance of CLEBP_S/Mth/Cth/Eth and CLEBP_S/M/C/E, we can get similar findings to the Outex database. On the other hand, as we can see from the table, the CLEBP_S/Mth/Cth/Eth shows a significant performance boost compared with traditional LBP and CLBP. For instance, with (P, R) = (1, 8), the classification rates obtained by CLBP with different numbers of training images (Nt = 40, 20, 10, and 5) are 87.64%, 85.70%, 82.65%, and 75.05%, respectively. With the same configuration setting, the CLEBP_S/Mth/Cth/Eth can reach the accuracy of 93.54%, 91.65%, 89.01%, and 82.29%, which has 38.89%, 38.71%, 41.87%, and 42.57% improvement over the traditional LBP. Similar conclusions to the proposed CLEBP_S/Mth/Cth/Eth can be found for other configuration settings.

Table 3 Classification accuracy (%) on UIUC
Full size table

To further highlight the performance of the proposed CLEBP_S/Mth/Cth/Eth, we select some classical LBP variants and state-of-the-art methods as the competitors. For example, with (P, R) = (16, 2) and Nt = 20, the CLEBP_S/Mth/Cth/Eth can reach the accuracy of 95.54%, which has 4.5%, 2.62%, 11.4%, and 4.86% improvement over CLBC, CRLBP (α = 1), BRINT, and AECLBP_S/M/C, respectively. In addition, compared with some state-of-the-art methods, the CLEBP_S/Mth/Cth/Eth significantly improves the best classification accuracy of recent texture descriptors on UIUC database. Specifically, with Nt = 20 and (P, R) = (1, 8), (16, 2), and (24, 3), the best classification accuracy obtained by CLEBP_S/Mth/Cth/Eth are 93.54%, 95.54%, and 96.40%, which outperform FbLBP by 1.5%, 1.4%, and 2.23%, and have 3.38%, 1.44%, and 2.63% improvement over CDLF_S/M/C_AHA, respectively. The experimental results demonstrate that the proposed CLEBP_S/Mth/Cth/Eth is a very discriminative and powerful texture descriptor for texture classification.

Experimental Results on the KTH-TIPS Database

In this section, we perform some comparative evaluations of the proposed CLEBP descriptors against some classical LBP variants and state-of-the-art methods in terms of classification rates on KTH-TIPS database. We could get the following finding from Table 4. Firstly, through the comparison of CLEBP_S_M/C/E and CLEBP_S_Mth/Cth/Eth, CLEBP_S/M/C/E and CLEBP_S/Mth/Cth/Eth, the same conclusion has been drawn that the classification accuracy has a significant improvement with the proposed multiscale thresholding strategy. In particular, with (P, R) = (8, 1), and Nt = 40, the CLEBP_S_Mth/Cth/Eth shows a performance boost of 1.2% compared with CLEBP_S_M/C/E. And similarly, the CLEBP_S/Mth/Cth/Eth achieves 1.04% improvement over CLEBP_S/M/C/E. Similar conclusions can be found in other cases. Once again, it is verified that the proposed multiscale thresholding strategy efficiently enhances the classification performance of texture descriptors and yields the best results in most cases.

Table 4 Classification accuracy (%) on KTH-TIPS
Full size table

Secondly, from Table 3, it can be found that the proposed CLEBP_S/Mth/Cth/Eth is comparable or outperform with most comparison methods. On one hand, the proposed CLEBP_S/Mth/Cth/Eth achieves higher classification accuracy than classical LBP variants. For example, with (P, R) = (8, 1), and N = 40, 20, 10, and 5, the classification accuracies achieved by CLEBP_S/Mth/Cth/Eth are 96.40%, 92.04%, 85.59%, and 75.64%, which could have 3.55%, 7.45%, 10.49%, and 11.95% improvement over the original LBP, 1.07%, 0.97%, 0.93%, and 1.93% higher than CLBP, and outperform LTP by 4.03%, 5.96%, 10.25%, and 10.51%, respectively. Similar conclusions to (P, R) = (16, 2) and (24, 3) can be found on the database. On the other hand, the CLEBP_S/Mth/Cth/Eth achieves competitive even better classification performance compared with the state-of-the-art methods. In particular, in the case of N = 40 and (P, R) = (8, 1), the CLEBP_S/Mth/Cth/Eth achieves the best classification accuracy with 96.40%, which outperforms DRLBP3 by 2.24%, has 0.57% improvement over LQC_C(2)N(4) and has a little higher than LQC_C(2)N(4), respectively. In other cases, it could still keep more or less superiority over the comparison methods. For example, the best classification accuracy of CLEBP_S/Mth/Cth/Eth in the case (P, R) = (24, 3) and Nt = 40 is 95.96%, which is 0.65% higher than LQC_C(6)N(4) and outperforms CLBC by 4.84%, respectively. The experimental results demonstrate that the proposed CLEBP_S/Mth/Cth/Eth is a powerful and effective texture descriptor.

Conclusion

In this paper, we develop a multiscale thresholding framework based on hierarchical adaptive local partition for binary encoding and present the CLEBP descriptor to extract comprehensive texture feature, which contains four components. Except with the three patterns from CLBP, we use the two-dimensional image entropy to build a novel local entropy binary pattern, which reflects the spatial characteristic of grayscale distribution. Then we extend the CLEBP with multiscale thresholding framework and propose CLEBP_S/Mth/Cth/Eth. Experimental results on three representative texture databases of Outex, UIUC, and KTH-TIPS show that the proposed multiscale thresholding framework is very discriminative and powerful, which helps the optimization of the binary coding. With the multiscale thresholding framework, the proposed CLEBP_S/Mth/Cth/Eth achieves competitive and superior texture classification performance, which is a powerful and effective texture descriptor for texture classification. In future works, we plan to develop an adaptive optimization technique to optimize the multiscale hierarchical threshold strategy. In addition, complementary solutions to the binary pattern family are of great interest to texture classification.