1 Introduction

Image segmentation has long played a vital role in computer vision and image processing. The image segmentation process produces a set of segments or regions. The accuracy of segmentation, though tough, is highly important in diverse fields like medical fields, remote sensing, and image retrieval, and it may contribute to saving, sustaining, and protecting human life. Image segmentation is generally performed with one of four different methods: thresholding, clustering, edge detection, and region extraction. Our work focuses on image segmentation by using the fuzzy clustering method. Many algorithms have been introduced for segmenting images using fuzzy clustering algorithms [1, 2]. Although the conventional fuzzy c-means (FCM) algorithm gives a good result for the images free from any type of noise, outliers, and imaging artifacts, because it does not use the local spatial information and it does not use a Euclidean distance metric that is non-robust. To overcome this drawback, a lot of enhanced FCM algorithms have been introduced that incorporate different components of local spatial information into the FCM objective function [3, 4].

Ahmed et al. [3] proposed FCM_S by adding a spatial neighborhood term into an objective function of original FCM algorithm. However, the main flaw of this algorithm is high running time because the added term is computed iteratively at every step.

Chen and Zhang [4] introduced FCM S1 and FCM S2 which are two versions of FCM_S method. The two versions FCM S1 and FCM S2 are proposed by replacing the neighborhood term FCM_S with priory calculated mean and median-filtered image in order time taken to calculate penalty term after every iteration.

Szilagyi et al. [5] contributed to fasten the process of segmentation by introducing an enhanced FCM (EnFCM) algorithm. First, a weighted image is obtained from the summation of the original image and the image formed from the mean of the pixels lying in a local window surrounding each pixel, and then, the resulting histograms are used to perform clustering. Therefore, the time complexity of EnFCM algorithm is very low.

Cai et al. [6] introduced the fast generalized FCM (FGFCM) algorithm where a similarity measure is used, which is a nonlinear weighted summed image that is obtained from the spatial and local intensity information. The histograms of the nonlinear weighted summed image are then used to perform clustering. Thus, the FGFCM algorithm is faster than EnFCM.

The above algorithms cannot directly be applied to the original image because their robustness to noise and their efficiency of segmentation are controlled by user-defined parameters and it is very difficult to automatically optimize these parameters. To overcome these drawbacks, [7] proposed an effective and robustly noise-invariant fuzzy local information c-means clustering algorithm (FLICM). FLICM is independent of any parameter-free algorithm and autonomously performs image segmentation to restrain the noise. An enhanced variant of the FLICM algorithm (RFLICM) [8] exploits local neighborhood information in depth by computing the relationship of pixels with neighbors to make FLICM more robust by replacing the Euclidean distance with the local coefficient of variation as a local similarity measure. These steps are taken to improve the segmentation results by restraining the noise of the image processed by the FLICM algorithm.

Currently, kernel methods are widely used in the field of machine learning. Now kernel methods have made it easy to solve complex nonlinear problems by representing them into low-dimensional feature space. The popular methods are support vector machines (SVM) [9,10,11]. In particular, kernel methods based on clustering algorithms [12] are found robust to noise. As a result, many modern image segmentation processes now use kernel-based clustering algorithms [13].

Chen and Zhang [4] presented two versions of KFCM which reduce the computational cost associated with the parent algorithm. In order to increase the robustness to noise capability of FLICM, Gong et al. [14] presented a kernel weighted fuzzy clustering with local information (KWFLICM) for image segmentation. KWFLICM uses the Gaussian radial basis function (GRBF) kernel [4] as a kernel function which adaptively calculates the parameter bandwidth \(\sigma\) within GRBF.

Generalized fuzzy c-means clustering algorithm incorporating local information for higher dimensional data has been proposed in order to overcome the disadvantages of FCM as well as to improve the clustering performance [15, 16].

The possibilistic fuzzy c-means (PFCM) algorithm [17] is formed by combining the possibilistic c-means (PCM) and FCM algorithms. The PFCM possess the properties of both PCM and FCM algorithms, and this overcomes many disadvantages of PCM, FCM, and FPCM, i.e., the noise sensitivity defects of FCM, the coincident clusters problem of PCM, eliminates the row sum constraints of PFCM. The kernel versions of PFCM (KPFCM) [11] are very robust to noise.

Therefore, by motivating from KPFCM, this work presents the kernel weighted possibilistic fuzzy c-means clustering with local information (KWPFLICM) algorithm to improve the performance of KWFLICM by removing noise more robustly.

The rest of the paper is organized into four sections. Section 2, describes our motivation of using the local spatial neighborhood information for PFCM. Section 3 explains our proposed algorithm in detail. In Sect. 4, describes and compares our experimental and numerical results. Finally, Sect. 5, draws conclusions.

2 Motivation

This work is inspired from FLICM [7], where a constraint factor \(G_{ab}\) is added that serves as a fuzzy local similarity measure, in order to remove noise and preserve the image details. Consider an image A with M pixels, where each pixel has a gray level \(p_a\). The grouping of image pixels \(\{p_i\}_{a=1}^M\) into k clusters is made as follows:

$$\begin{aligned} J_m = \sum _{a=1}^M \sum _{b=1}^k u_{ab}^m \left\| p_a -c_b\right\| ^2 +G_ab \end{aligned}$$
(1)

where m represents the degree of fuzziness (usually \(m=2\)) and the partition array \(U = \{u_{ab}\}\) denotes the belongingness of image intensity values to each cluster. The members of the U array must satisfy the following condition

$$\begin{aligned} U \in \left\{ {\sum \limits _{b = 1}^k {u_{ab} } \in \left[ {0,1} \right] \left| {\sum \limits _{b = 1}^k {u_{ab} = 1,\quad \forall b\;\hbox {and}\;0< \sum \limits _{a = 1}^M {u_{ab} < M,\forall b'} } } \right. } \right\} \end{aligned}$$
(2)

The fuzzy factor \(G_{ab}\) is defined as

$$\begin{aligned} G_{ab} = \sum _{j \in M_i, a \ne j}\frac{1}{d_{aj}+1} \left( 1-u_{bj}\right) ^m \left\| p_j - c_b \right\| ^2 \end{aligned}$$
(3)

where the rectangular local window is used around the central pixel \(p_a\), \(M_a\) is the set of neighbors of ath central pixel obtained by applying a rectangular window around the central pixel, the jth pixel belongs to \(M_a\), and \(d_{aj}\) is the spatial Euclidean distance between the pixels a and j. The variable \(u_{ab}\) denotes the degree of belongingness of pixel \(p_a\) to cluster b, and \(c_b\) is the prototype of bth cluster. The fuzzy clustering is performed through an objective function, \(J_m\), optimization by updating the membership \(u_{ab}\) and the cluster center \(c_b\), calculated as follows:

$$\begin{aligned} u_{ab}\,= & {} \frac{1}{{\sum \nolimits _{l = 1}^k {\left( {\frac{{\left\| {p_a - c_b } \right\| ^2 + G_{ab} }}{{\left\| {p_a - c_l } \right\| ^2 + G_{al} }}} \right) } }}\end{aligned}$$
(4)
$$\begin{aligned} c_b\,= & {} \frac{{\sum \nolimits _{a = 1}^M {u_{ab}^m} p_a }}{{\sum \nolimits _{a = 1}^M {u_{ab}^m } }} \end{aligned}$$
(5)

where \(G_{ab}\) is automatically calculated even in the absence of any prior knowledge of noise. Due to this intentionally weighted approach, the FLICM algorithm is more robust to outliers.

Gong et al. [14] proposed KWFLICM to make FLICM algorithm more robustness to noise and outliers by opting a trade-off between a weighted fuzzy factor and the kernel method. The KWFLICM minimizes the following objective function:

$$\begin{aligned} J_m = \sum \limits _{a = 1}^M \sum \limits _{b = 1}^k u_{ab}^m \left( 1 - K(p_a ,c_b ) \right) + G_{ab}^{'} \end{aligned}$$
(6)

where enhanced fuzzy local similarity measuring factor, \(G_{ab}^{'}\) is calculated as follows:

$$\begin{aligned} G_{ab}^{'} = \sum \limits _{a = 1}^M {\sum \limits _{b = 1}^k {u_{ab}^m } \sum \limits _{\mathop {a \ne j}\limits _{j_{}^{} \in _{}^{} M_b } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \left( {1 - K(p_j ,c_b )} \right) } \end{aligned}$$
(7)

where \(w_{aj}\) represents the trade-off of the weighted fuzzy factor of the jth pixel. The non-Euclidean distance between pixels is calculated by \((1-K(p_j,c_b ) )\), based on the kernel method. The updated memberships \(u_{ab}\) and cluster centers \(c_b\) are calculated to minimize the objective function \(J_m\):

$$\begin{aligned} \begin{array}{l} u_{ab} =\frac{1}{{\sum \nolimits _{l = 1}^k {\left( {\frac{{\left( {1 - K(p_a ,c_b )} \right) + \sum \nolimits _{\mathop {a \ne j}\nolimits _{j_{}^{} \in _{}^{} M_b } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \left( {1 - K(p_j ,c_b )} \right) }}{{\left( {1 - K(p_a ,c_l )} \right) + \sum \nolimits _{\mathop {a \ne j}\nolimits _{j_{}^{} \in _{}^{} M_b } } {w_{aj} } \left( {1 - u_{lj} } \right) ^m \left( {1 - K(p_j ,c_l )} \right) }}} \right) ^{\frac{1}{{m - 1}}} } }} \\ \end{array}\end{aligned}$$
(8)
$$\begin{aligned} c_b = \frac{{\sum \nolimits _{a = 1}^M {u_{ab}^m K(p_a ,c_b )} p_a }}{{\sum \nolimits _{a = 1}^M {u_{ab}^m K(p_a ,c_b )} }} \end{aligned}$$
(9)

Local coefficient of variation \(V_j\) for each jth neighbor pixel is calculated as follows:

$$\begin{aligned} V_j = \frac{{{\mathrm{var}} (p)}}{{\left( {\overline{p} } \right) ^2 }} \end{aligned}$$
(10)

where var(p) and \(\overline{p}\) represent the pixel intensity value variance and mean value of the local window, respectively. The mean of the \(V_j\) for all neighbors belonging to \(M_a\) is obtained by

$$\begin{aligned} \overline{V} = \frac{{\sum \nolimits _{j \in M_a }^{} {V_j } }}{{n_a }} \end{aligned}$$
(11)

where \(n_a\) represents the local cardinality of the local window.

$$\begin{aligned}&\chi _{aj} = \exp \left[ { - \left( {V_j - \overline{V} } \right) } \right] ,_{}^{} j \in M_a \end{aligned}$$
(12)
$$\begin{aligned}&\psi _{aj} = \frac{{\chi _{aj} }}{{\sum \nolimits _{i \in M_a } {\chi _{ai} } }} \quad \text {and} \quad w_{gc} = \left\{ \begin{array}{l} 2 + \psi _{aj} \qquad V_j < \overline{V} \\ 2 - \psi _{aj} \qquad V_j \ge \overline{V} \\ \end{array} \right. \end{aligned}$$
(13)

Here, a constant value 2 is added to ensure that \(w_{gc}\) is always nonnegative. The \(w_{aj}\) used in the enhanced \(G_{ab}^{'}\) formula is obtained by

$$\begin{aligned} w_{aj} = \left( {\frac{1}{{d_{aj} + 1}}} \right) w_{gc} \end{aligned}$$
(14)

KWFLICM uses the GRBF kernel function and computes as follows:

$$\begin{aligned}&K(p_a ,c_b ) = {\mathop { e}\nolimits } ^{\left( { - \frac{{\left\| {p_a - c_b } \right\| ^2 }}{\sigma }} \right) }\end{aligned}$$
(15)
$$\begin{aligned}&\quad \overline{p} = \frac{{\sum \nolimits _{a = 1}^M {P_a } }}{M}\end{aligned}$$
(16)
$$\begin{aligned}&\quad d_a = \left\| {P_a - \overline{p} } \right\| \end{aligned}$$
(17)
$$\begin{aligned}&\quad \overline{d} = \frac{{\sum \nolimits _{a = 1}^M {d_a } }}{M} \end{aligned}$$
(18)

The bandwidth parameter \(\sigma\), is found by

$$\begin{aligned} \sigma = \frac{1}{{\sqrt{\frac{1}{{M - 1}}\sum \nolimits _{a = 1}^M {(d_a - \overline{d} )^2 } } }} \end{aligned}$$
(19)

As such, the distance for multi-dimensional dimensional feature space can then be computed as:

$$\begin{aligned} D_{ab}^2 = 1 - K(p_a ,c_b ) = 1 - e^{\left( { - \frac{{\left\| {p_a - c_b } \right\| ^2 }}{\sigma }} \right) } \end{aligned}$$
(20)

Though both FLICM and KWFLICM algorithms are found robust to noise still there is a need of method to deal higher degrees noise.

3 Methodology

Motivated by the above-mentioned descriptions, we propose a kernel weighted possibilistic fuzzy c-means using local information for image segmentation (KWPFLICM) algorithm for robust noise removal. The KWPFLICM minimizes the following objective function:

$$\begin{aligned} J_m = \sum \limits _{a = 1}^M {\sum \limits _{b = 1}^k {\left\{ \begin{array}{l} \sum \limits _{k = 1}^c {} u_{ab}^m t_{ab}^m \left( {1 - K(p_a ,c_b )} \right) \\ \,\,+ \sum \limits _{b = 1}^k {\gamma _b } \sum \limits _{a = 1}^M {u_{ab}^m } \left( {1 - t_{ab} } \right) ^n + G_{ab}^{''} \\ \end{array} \right\} } } \end{aligned}$$
(21)

Our enhanced \(G_{ab}^{''}\) fuzzy factor is calculated as:

$$\begin{aligned} G_{ab}^{''} = \sum \limits _{a = 1}^M {\sum \limits _{b = 1}^k {\left\{ \begin{array}{l} u_{ab}^m \sum \limits _{\mathop {a \ne j}\limits _{j_{}^{} \in _{}^{} M_i } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \\ \,\,\times \left( {1 - t_{bj} } \right) ^n \left( {1 - K(p_j ,c_b )} \right) \\ \end{array} \right\} } } \end{aligned}$$
(22)

where \(p_a\) represents the central pixel \(p_j\) belongs to the jth neighboring pixel from the set of neighbors of \(p_a\), i.e., \(p_a(M_i)\). The variable \(d_{aj}\) denotes the spatial Euclidean distance of pixel a with j. The coefficients \(u_{ab}\) and \(t_{ab}\) represent the degree of fuzzy membership and possibilistic typicality of pixel \(p_j\) for the cluster b, respectively, and \(c_b\) is the prototype of the bth cluster. The exponent m represents the degree of fuzzy, n is the weighted index of typicality, and the parameter \(\gamma _b\) of cluster b is a right positive value, which is defined from objective function as

$$\begin{aligned} \gamma _b = 2K\frac{{\sum \nolimits _{a = 1}^M {u_{ab}^m t_{ab}^m \left( {1 - K(p_a ,c_b )} \right) } }}{{\sum \nolimits _{a = 1}^M {u_{ab}^m t_{ab}^m } }} \end{aligned}$$
(23)

Normally, the value of K is set to 1.

The fuzzy membership \(u_{ab}\), possibilistic typicality \(t_{ab}\), and center \(c_b\), which are collectively used to minimize the objective function, are defined as follows:

$$\begin{aligned} \begin{array}{l} u_{ab} =\frac{1}{{\sum \nolimits _{l = 1}^k {\left( {\frac{{t_{ab} \left( {1 - K(p_j ,c_b )} \right) + \sum \nolimits _{\mathop {a \ne j}\nolimits _{j_{}^{} \in _{}^{} M_i } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \left( {1 - t_{bj} } \right) ^n \left( {1 - K(p_j ,c_b )} \right) }}{{t_{al} \left( {1 - K(p_j ,c_b )} \right) + \sum \nolimits _{\mathop {a \ne j}\nolimits _{j_{}^{} \in _{}^{} M_i } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \left( {1 - t_{bj} } \right) ^n \left( {1 - K(p_j ,c_b )} \right) }}} \right) ^{\frac{1}{{m - 1}}} } }} \\ \end{array} \end{aligned}$$
(24)
$$\begin{aligned} \begin{array}{l} t_{ab} =\frac{1}{{\left\{ {1 + 2\left( {\frac{{\left( \begin{array}{l} (1 - K(p_i ,c_b )) + \sum \nolimits _{\mathop {a \ne j}\nolimits _{j_{}^{} \in _{}^{} M_i } } {w_{aj} } \left( {1 - u_{bj} } \right) ^m \\\quad \times \left( {1 - t_{bj} } \right) ^n \left( {1 - K(p_j ,c_b )} \right) \\ \end{array} \right) }}{{\gamma _b }}} \right) ^{\frac{1}{{n - 1}}} } \right\} }} \\ \end{array} \end{aligned}$$
(25)
$$\begin{aligned} c_b = \frac{{\sum \nolimits _{a = 1}^M {u_{ab}^m t_{ab}^n (1 - K(p_i ,c_b ))} p_a }}{{\sum \nolimits _{a = 1}^M {u_{ab}^m t_{ab}^n K(p_i ,c_b )} }} \end{aligned}$$
(26)

In order to overcome convergence to the trivial solution, the middle term is added in the objective function of the proposed method. Steps of our proposed KWPFLICM are mentioned below.

Step 1 :

Set the values for typicality n, local window size \(M_a\), fuzzifier m, the maximum iteration number \(itr_{\max}\), and set the threshold for stopping the algorithm, \(\epsilon\).

Step 2 :

Initialize cluster centers, fuzzy membership, and kernel function with the resultant cluster center, respectively, obtained by running the KWFLICM algorithm.

Step 3 :

Compute \(w_{aj}\) and \(D_{ab}^2\) by using Eqs. (14) and (20), respectively.

Step 4 :

Compute the \(\gamma _b\) parameter by using Eq. (23)

Step 5 :

Update by Eq. (25)

Step 6 :

Update by Eq. (24)

Step 7 :

Update by Eq. (26)

Step 8 :

Stop if \(\max \left\| C^{(itr)}-C^{(itr+1)} \right\| < \epsilon\) or \(itr>itr_{\max }\), otherwise \(itr = itr+1\), and go to Step 4.

The flowchart as shown Fig. 1 describes detailed elaboration of the steps of the proposed KWPFLICM algorithm.

Fig. 1
figure 1

The flowchart of the proposed KWPFLICM algorithm

Full size image

The defuzzification of the fuzzy segmented image into a crisp, segmented image takes place after algorithm converges by using the maximum membership method of defuzzification. In this method, the ath pixel with the highest membership is assigned to class \(c_b\):

$$\begin{aligned} c_b = \arg \left\{ {\max \left\{ {u_{ab} } \right\} } \right\} ,\,\,(b = 1,2,\dots ,c) \end{aligned}$$
(27)

4 Experimental Results and Analysis

This section evaluates the segmentation performance of KWPFLICM by segmenting the synthetic, natural, and real images that have different types of noise added. We generally use throughout all the experiments a fixed value for \(\epsilon =0.001\), \(M_a= 8\) (a \(3 \times 3\) local window centered on each pixel, except for the central pixel itself), fuzzifier \(m=2\) and for KWPLFICM, \(a= 2\) and \(b=2\). Furthermore, the segmentation results of KWPFLICM are compared with four other algorithms that use pixels’ local neighborhood information, i.e., FLICM [1], RFLICM [12], WFLICM, and KWFLICM, in order to measure the robustness and efficiency of KWPFLICM.

4.1 Results on the Synthetic Images

In this section, we use two synthetic test images composed of \(120 \times 120\) pixels each and are shown in Figs. 2a and 3a. The number of cluster sets is 4 and 2 for synthetic image-1 and synthetic image-2 as shown in Figs. 2a and 3a, respectively. We added different degrees of Gaussian and salt-and-pepper noise to these images then we applied the above-mentioned algorithms on the obtained corrupted image. The denoising performance of all of the algorithms is measured by the optimal segmentation accuracy (SA), and the SA is computed by the following equation [3]:

$$\begin{aligned} SA = \sum \limits _{b = 1}^k {\frac{{\alpha _b \cap \beta _b }}{{\sum \nolimits _{j = 1}^k {\beta _j } }}} \end{aligned}$$
(28)

where \(\sigma _b\) denotes the all the pixels belonging to the bth class after segmentation process finished, k is the number of clusters, and \(\sigma _b\) denotes the all pixels belonging to the bth class in the reference segmented image.

Figure 2c–f shows the clustering results of all the algorithms operating on synthetic image-1 corrupted with 40% of Gaussian noise. Figure 3c–f shows the clustering results of all the algorithms operating on synthetic image-2 corrupted with 60% of Gaussian noise. Figures 2 and 3 reveal that the FLICM, RFLICM, and WFLICM algorithms are not robust to noise and in fact are heavily affected by noise. While KWFLICM, shown in Figs. 2f and 3f, demonstrates good noise removal, the presence of artifacts indicates that it is not a thoroughly robust noise removal algorithm. However, our proposed algorithm, shown in Figs. 2g and 3g, is very robust to noise because KWPFLICM removes the entire added noise which is a highly satisfactory result. Table 1 describes the segmentation accuracy (SA) obtained from the experiments performed by using synthetic image-1 corrupted with various degrees of Gaussian noise (G) and salt-and-pepper noise (SP). Hence, KWPFLICM is found more robust to noise than all other algorithms for synthetic images.

Fig. 2
figure 2

Segmented results for the Synthetic image-1: a Original image, b corrupted by (40%) Gaussian noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image
Fig. 3
figure 3

Segmented results for the Synthetic image-2: a Original image, b corrupted by (60%) Gaussian noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image
Fig. 4
figure 4

Segmented results for the Cameraman natural image: a Original image, b corrupted by (50%) Gaussian noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image
Fig. 5
figure 5

Segmented results for the scene natural image: a Original image, b corrupted by (50%) Gaussian noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image
Table 1 SA (%) on synthetic image-1 with various levels
Full size table

4.2 Results for Natural and Real Images

The natural and real images are used to perform this experiment. We cannot calculate the segmentation accuracy because this type of image does not have an unambiguous ground truth available. Therefore, an entropy-based information evaluation function [18] is used to assess the performance of all of the above-mentioned algorithms. The entropy of the cluster or region k is defined as

$$\begin{aligned} H(R_b ) = - \sum \limits _{m \in V_b } {\frac{{L_b (m)}}{{S_b }}} \log \frac{{L_b (m)}}{{S_b }} \end{aligned}$$
(29)

The segmented image expected entropy is described as

$$\begin{aligned} H_r (I) = \sum \limits _{b = 1}^k {\left( {\frac{{S_b }}{{S_I }}} \right) } H(R_b ) \end{aligned}$$
(30)

The entropy of the layout is described as

$$\begin{aligned} H_l (I) = - \sum \limits _{b = 1}^k {\left( {\frac{{S_b }}{{S_I }}} \right) } \log \frac{{S_b }}{{S_I }} \end{aligned}$$
(31)

Entropy-based information evaluation function can be calculated as

$$\begin{aligned} E = H_l (I) + H_r (I) \end{aligned}$$
(32)

where \(R_b\) denotes the sub-segments of the original image, \(L_b(m)\) represents the number of pixels in the bth region (cluster) having a intensity value m, \(v_b\) is the set of possible gray-level values in the bth cluster (\(R_b\)), and \(S_b=|R_b |\) is the cardinality. The minimal value of E shows the best segmentation performance.

The first natural image chosen is “cameraman” of size \(512 \times 512\) pixels, as shown in Fig. 4a. The second natural image “scene” is obtained from the University of Massachusetts at Amherst [19], where the image is mainly composed of three different regions, namely, sky, forest, and road, with the dimension of \(200 \times 200\) pixels as mentioned in the literature shown in Fig. 5a.

Furthermore, the cameraman image is contaminated with 50% of Gaussian noise, as shown in Fig. 4b. The number of clusters for the cameraman image is set to 3. The scene image is contaminated with 15% of Gaussian noise, as shown in Fig. 5b.

Figure 4c–g shows the clustering results of all algorithms on the noisy cameraman image, and Fig. 5c–g shows the clustering results of all algorithms on the noisy scene image. Table 2 describes the entropy obtained from the experiments performed by using cameraman image corrupted with various degrees of Gaussian noise and salt-and-pepper noise. It is clear from the results that the FLICM, RFLICM, WFLICM, and KWFLICM algorithms are influenced by noise. Hence, it is demonstrated that these four algorithms are sensitive to salt-and-pepper or Gaussian noises. In contrast, the results of our proposed algorithm show that it eliminates the noise effectively and preserves the clear edges and details of the image.

Table 2 Entropy-based evaluation of cameraman image corrupted by Gaussian noise (50%)
Full size table

In the final experiment, in order to show the effect of noise on real images, real images namely “wolf and “stag” are taken from Berkeley Segmentation Dataset and Benchmarks 500 (BSDS500) [20] used for segmentation. Both real images are constituted by \(480 \times 320\) pixels. The distinct number of regions/classes for wolf image is considered three namely: background, grass, and wolf as shown in Fig. 6a. The distinct number of regions/classes for stag image is considered three as shown in Fig. 7a. We have added 25% and 50% Gaussian noise to the original wolf image and stag as corrupted images are shown in Figs. 6b and 7b, respectively, then we have applied clustering methods on these corrupted images. Segmentation result of all the algorithms under consideration is shown in Figs. 6c–g and 7c–g. Table 3 describes the entropy obtained from the experiments performed by using wolf image corrupted with various degrees of Gaussian noise and salt-and-pepper noise. Segmentation results depicted in Figs. 6 and 7, and Table 3 prove that KWPFLICM is found more robust to noise than all other algorithms.

Table 3 Entropy (E) on real wolf noisy image corrupted by various levels
Full size table
Fig. 6
figure 6

Segmented results for the “wolf image: a Original image, b corrupted by (25%) Gaussian Noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image
Fig. 7
figure 7

Segmented results for the “stag image: a Original image, b corrupted by (50%) Gaussian Noise, c FLICM, d RFLICM, e WFLICM, f KWFLICM, g KWPFLICM

Full size image

5 Conclusion

In this paper, a new kernel possibilistic fuzzy clustering algorithm is proposed for the robust segmentation of noisy images. Simulation results have demonstrated that kernel-based possibilistic fuzzy clustering is an effective technique for robust image clustering. Our proposed algorithm is a parameter-free approach that improves image segmentation performance. Furthermore, relative to preexisting algorithms, this method shows enhanced robustness to various types of noise and outliers. This algorithm does have the drawback of a high time complexity due to the computation of the fuzzy factor \(G_{ab}^{''}\) in each iteration, but its exceptional performance in experiments compensates for this weak point.