Bitwise Operations of Cellular Automaton on Gray-scale Images

TL;DR

This paper explores the use of cellular automata on gray-scale images by converting them into binary images, applying CA-based denoising, and recombining them using a multinomial regression method, showing promising results against standard denoising techniques.

Contribution

The paper introduces a multinomial regression based weighted recombination method for binary images processed by cellular automata on gray-scale images, enhancing denoising performance.

Findings

CA invariance to noise realization and pixel sub-sampling

Simple local minima algorithms perform as well as global minima methods

Effective denoising of Salt and Pepper noise compared to median filter

Abstract

Cellular Automata (CA) theory is a discrete model that represents the state of each of its cells from a finite set of possible values which evolve in time according to a pre-defined set of transition rules. CA have been applied to a number of image processing tasks such as Convex Hull Detection, Image Denoising etc. but mostly under the limitation of restricting the input to binary images. In general, a gray-scale image may be converted to a number of different binary images which are finally recombined after CA operations on each of them individually. We have developed a multinomial regression based weighed summation method to recombine binary images for better performance of CA based Image Processing algorithms. The recombination algorithm is tested for the specific case of denoising Salt and Pepper Noise to test against standard benchmark algorithms such as the Median Filter for various images and noise levels. The results indicate several interesting invariances in the application of the CA, such as the particular noise realization and the choice of sub-sampling of pixels to determine recombination weights. Additionally, it appears that simpler algorithms for weight optimization which seek local minima work as effectively as those that seek global minima such as Simulated Annealing.

Tables

Table 1. TABLE I : PSNR Values achieved with various methods at different noise levels for SPN noise. 128x128 Lena Image is used for all comparisons.

	p = 0.06	p= 0.08	p = 0.1	p = 0.12	p = 0.14
Median Filtering	17.2	16.33	15.42	14.69	13.81
Using W = [1,1.. 1]	18.94	18.04	17.34	16.69	15.8
$\eta$ = 100%	20.1	19.98	19.63	19.34	18.65
$\eta$ = 10%	20.1	19.98	19.63	19.33	18.64

Table 2. TABLE II : Various Statistical Parameters for weights obtained after regression for three different iterations. Each Iteration was run for 7560 epochs for improvement of Mean Square Error. Image used is 256x256 Baboon Image, noise levels as 0.09 for Iteration #1 , 0.10 for Iteration#2 and 0.11 for Iteration#3 with η 𝜂 \eta = 10%

	MEAN	MEDIAN	STD	MIN	MAX	SUM
Iteration #1	0.8296	1.1596	1.0535	-1.9828	1.9901	211.245
Iteration #2	0.832	1.1627	1.0746	-1.9617	1.9946	212.991
Iteration#3	0.842	1.1495	1.0611	-1.898	1.9998	213.5419

Equations

$$B_r^1({\mathbf{x}}_{\mathbf{c}}):=\{\mathbf{x}:|\mathbf{x}-{\mathbf{x}}_{\mathbf{c}}{|}_1\le r\};\mathbf{x}=⟨x,y⟩$$

$$B_r^{\infty }({\mathbf{x}}_{\mathbf{c}}):=\{\mathbf{x}:|\mathbf{x}-{\mathbf{x}}_{\mathbf{c}}{|}_{\infty }\le r\};\mathbf{x}=⟨x,y⟩$$

$$T_k:$$

$$A_X(i,j,k):=T_k(X)(i,j)$$

$$I_k(i,j)=:\{\begin{array}{ll}1& X(i,j)\ge k\\ 0& Otherwise\end{array};k\in \{0,1,2,\cdots ,255\}$$

$$T_k^{\prime }:\{A_X^{\prime }|A(i,j,k)\in 0,1\}\to \{X^{\prime }|I(i,j)\in \{0,1\}\}$$

$$\sum _{k=1}^t{w}_k{A}_X^{\prime }(k)=X^{\prime }$$

$$W=\underset{w_k\ge 0}{\min }{\sum \sum }_{(i,j)\in A\ast }|X^{\prime }(i,j)-X(i,j){|}^2$$

$$W=\underset{w_k\ge 0}{\min }{\sum \sum }_{(i,j)\in A_{\eta }}|X^{\prime }(i,j)-X(i,j){|}^2$$

$$MSE=\frac{\sum _{i=0}^{m-1}\sum _{j=0}^{n-1}[I(i,j)-K(i,j){]}^2}{mn}$$

$$PSNR=10\log_{10}\Big{(}\frac{255^{2}}{MSE}\Big{)}$$

Full text

I INTRODUCTION

The idea of the Cellular Automaton in its present form was conceptualized by J. Von Numann and Stan Ulam [1]. A rich theory for CA was worked out by Steven Wolfram [2]. For completing computation heavy tasks in real time, parallel computing is one of the brightest hopes and CA models lend very easily to parallel implementation due to the inherent independence in their model structure [3]. Image processing requires heavy computation in realtime and thus CA is a very intuitive and natural candidate for the task.

Digital image processing is an integral part of modern day signal processing, with applications ranging from Magnetic Resonance Imaging to Satellite Television. One of the major problems faced is the corruption of images by various noise sources. Out of the many possible noises, impulse noise, such as Salt and Pepper, is a common challenge in image processing: it is routinely caused by a number of possible aberrations such as malfunctioning of sensors, noisy transmission over a channel leading to loss of some bits, or corruption in specific memory locations [4].

A standard approach to reduce salt and pepper noise is the use of median filters [6][5]. Popvici et al. designed a local transition function such that the current cell’s state is a function of the previous states of the neighboring cells [7]. However, these methods are not optimal since, these are agnostic to the presence of local features like edges and hence output blurry images especially for high noise levels. [8] provides a CA algorithm to deal with higher noise levels. Rosin et al. propose a greedy approach to rule selection that includes denoising salt and pepper noise [9] using CA. Although each cell only sees and interacts with a few other cells according to some simple rules, the combination of these local interactions can cause complex non-linear global behavior as seen in the famous example of Conway’s Game of Life [10].

Due to these promising advancements in the use of CA for denoising Salt and Pepper noise, we have chosen it as a model for demonstrating our general algorithm for extending CA methods to gray scale images. Moreover, it allows for comparison against standard benchmark algorithms such as the median filter.

A major hurdle for wider application of CA theory is the limitation to a very small number of allowable states for the image. Generally, the number of allowable states is limited to just two or three because of the exponential dependence of the size of the search space of allowable rule-sets on the number of possible states for each cell. This makes the problem of finding suitable rule-sets for any application very computationally intensive, especially when rather larger numbers of possible states need to be condsidered. In our work, we propose to overcome this hurdle by actually constraining the search space for rule sets to only two possible states (Binary images) for each pixel for each CA in use, but still providing for application of CA to Grayscale images that actually have 256 possible states for each pixel.

Section II describes the CA framework for application of the Recombination Algorithm. The first sub-section introduces the general CA setting and the standard definitions and terms. The second sub-section narrows the setting to that of binary images and finally, the last sub-section describes the step-wise algorithm for extension of Binary methods to gray-scale images. The second section introduces our proposed Recombination Algorithm which is followed by the simulation results and discussion. We end with acknowledgments and referencesmakemytrip .

II CA MODEL FOR DIGITAL IMAGES

A Cellular Automaton model for operations on images is essentially defined by a two dimensional grid like structure with each cell belonging to a particular state that is chosen from a set of finitely many choices at each time step. Moreover, this state changes in time according to a well defined set of rules governing the ’evolution’ of CA which might take into account a history of all the previous states for both the cell and its neighbors. This ’rulebook’ is generally taken to be time-invariant and independent of the cell in question [2].

II-A Model structure and parameters

A two dimensional deterministic CA can be understood and represented as an ordered three tuple $\langle S,B^{1}_{r},\Delta\rangle$ where $S$ is the State set. A standard way to define neighborhood $B^{1}_{r}\in\mathbf{Z^{2}}$ is to use a ball defined by a metric $B^{1}_{r}(\bf{x},\bf{x_{c}})$ [7]. Different metrics lead to a variety of neighborhoods such as Von Neumann Neighborhood:

[TABLE]

Similarly, Moore Neighborhood is defined by the norm [11]

[TABLE]

$\Delta$ is a function that has the argument as current state of the given cell and its neighborhood and returns the next state of the given cell, according to a deterministic rule. The set of states, the neighborhood patterns and the rule set ($\Delta$) along with the initial states completely define a certain CA.

II-B Application of CA to Binary Images

A binary image in CA framework is modeled as a 2-dimensional binary state CA with a Moore neighborhood of $r$ = 1 or 2 in most cases. In general, the inverse problem of finding the rule set for use of CA to perform a given image processing task is highly computationally intensive. For a CA with $S$ states and a neighbourhood consisting of $N$cells $\Delta$ has a total of $S^{S^{N}}$ possible choices. Even with a case as small as that of Moore neighborhood with $R$ = 1 ($N$ = 8) with binary states, there are more than $10^{77}$ possible rulesets. This exponential dependence makes it pragmatically computationally impossible to evaluate every possible ruleset combination for any given task and choose the one with the best performance.

Many different tricks can be employed for working around this problem. The most employed of them is the restriction of input to binary images ($S$=2). The reason for this is to limit the number of possible rulesets to as small as possible. Still, since the possible number is quite large, some researchers have chosen these rulesets heuristically by hand [12]. On the other hand, Rosin et al. have applied a general framework known as Sequential Forward Floating Search (SFFS) for greedily identifying the rulesets that perform optimally at each step [9].

II-C Extension to Grayscale Images

Restricting the input to binary images poses the problem of application of CA to grayscale images. One of the common strategies applied is to convert the original grayscale $m\times n$ image to a number of different binary $m\times n$ images. Then, we apply CA individually to each of these binary images and finally recombine them to obtain the final grayscale image. Mathematically, these three steps can be described as the following operations:

Step 1: Thresholding the Grayscale Image

In the first step, for conversion to binary images, a number of strategies are used. A binary threshold can be introduced at each value of set $K=\{k_{i}\}$ of chosen intensity values, which could even be all (256 in total) of the available grey levels. We define an auxiliary transformation $T_{k}$ as follows:

[TABLE]

Thus, $A_{X}$ is a $k$-indexed stack of $|K|$ binary images. For example, one interpretation of the above would be

[TABLE]

This would generate 256 binary images from each grayscale image.

Another possible implementation is to threshold not at all the possible gray values, but only at the positive powers of 2 until 255. So, in the above notation then, $k\in\{1,2,4,8,16,32,64,128\}$ , which are usually termed as the eight bitplane images. This has the advantage of reducing the number of binary images from 256 to only 8 possible images with a corresponding reduction in computation time. However, the loss of original intensity information here is too large and thus the resulting image is significantly blurred on recombination.

A third possible method for decomposition is to divide the input image into a number of different non-overlapping patches and then compute OTSU thresholds for each of these patches separately [13] and now use these computed thresholds as values of $k$ over the entire image. Though these computed thresholds are specific to the image, hardly any performance boost is achieved by cutting down on the number of thresholds using this method, because depending upon the number of non-overlapping regions selected, these thresholds can themselves become too many in number and present a more or less uniform distribution over the interval [0,255]. Thus, a good option for a thresholding step is to either threshold at every possible value $k\in\{0,1,2,\cdots,255\}$ or to uniformly sample half or one third of this complete set, for example $k\in\{1,4,7\cdots,253\}$ etc.

Step 2: Application of CA rules

In this step, each binary image resulting from Step 1 is applied to a CA to obtain an equal number of output binary images.

$CA:\{\,A_{X}\mapsto A_{X}^{\prime}\,\}$

$A_{X}^{\prime}$ is also a stack of $|K|$ binary images.

The selection of the rules is an entire problem in itself. [14] works on using CA for pattern classification. [15] and [9] propose methods for generating rule sets for thinning, denoising, convex hull detection etc. [4] proposes a majority rule for denoising SPN noise. [16] develops algorithm for arbitrary rotation of images using two dimensional CA. At Step 2, any of these rules maybe applied individually over each component binary image $I_{k}$ generated after Step 1. The selection of the particular CA rule depends upon the application at hand and the method being employed. Once selected, the rules are applied on individual pixels of the binary image $I_{k}$ and result is stored in the output images at the identical position. For our demonstration in this paper, we have chosen salt and pepper denoising.

Step 3: Recombination to Form the Output Grayscale Image

[TABLE]

This is where our work makes the most contribution. The recombination algorithm in general, depends upon the method employed for thresholding in Step 1, but our proposed method takes into account this complication and adjusts itself so as to deliver the optimal output. The trade off is a corresponding increase in computation time but that can be circumvented by pre-processing the image.

III Recombination Algorithm

We propose a regression based weighed combination of binary images in Step 3 of the process. Suppose the chosen set of thresholds in Step 1 is $K=\{k_{1},k_{2},\ldots,k_{t}\}$, then for $w_{k}>0$ we propose the recombination:

[TABLE]

where $A^{\prime}_{X}$ is the binary image stack generated from applying CA operations to the $k$th binary image. $X^{\prime}$ is our approximation of the desired output image. To find these weights $w_{k}$, we try to iteratively minimize the Mean Square Error between the uncorrupted pixels and the regenerated image $X^{\prime}$. This approach assumes we have the knowledge of pixels that are uncorrupted by SPN noise which is easily gained by excluding the pixels having either very high (255) or very low (0) intensity values. Thus, the weight vector $W$ = $[w_{1}$,$w_{2}$, $\ldots$ ,$w_{t}]$ is obtained as:

[TABLE]

where $A$ is the set of all uncorrupted $(i,j)$.

A possible economization is to uniformly sample a pre-decided percentage of pixels ($\eta$%) from $A*$ and use that for calculating $W$ instead of complete $A$. So,

[TABLE]

The vector $W$ has to be appropriately randomly initialized for fast convergence. A good initialization is to use a set of uniform weights $w_{k}=\mu=255/t;k={1,2,\ldots,|K|}$ because, this would have been the best estimate for weights had the CA operations not taken place. So, we may choose $w_{k}\sim U[(1-\epsilon)\mu,(1+\epsilon)\mu]$ for a small $\epsilon>0$ such as 0.05. In practice, a value of $\eta$ = 0.1 was observed to be exactly as good as using the complete $A*$ for images down to 64 $\times$ 64 pixels in size.

IV Simulations

As can be seen from Fig.1 for $\eta$ as small a 1% for a large enough image, the PSNR value does not depreciate much from what is achieved by using all uncorrupted pixels. This provides a speedup of two-orders for magnitude making the algorithm good enough for real-time implementation given a parallel architecture. But for smaller images (128x128 in size) for $\eta$ $\leq$ 10% the number of samples become too less to have the same information as required and the performance suffers a lot. Thus, we choose $\eta=10\%$ for other simulations also.

We have tested the algorithm for SPN noise varying from p = 0.01 to 0.2. At higher noise levels, the amount of uncorrupted pixels that can be reliably observed and used for regression, decreases. We have used Peak Signal to Noise Ratio (PSNR) as a metric to compare algorithm’s performance.Given a noise-free m×n monochrome image I and its noisy approximation K, MSE is defined as [17]

[TABLE]

Consequently, Peak Signal to Noise Ratio (PSNR) is calculated as:

[TABLE]

Table 1 lists the various PSNR values achieved in the mid noise levels. Clearly, the SPN denoising algorithm performs better than the standard median filter consistently over various realizations and levels of noise. We have used thresholding at all possible values for testing and evaluation of the SPN denoising algorithm. Thus, setting the W vector identically to 1 is equivalent to circumventing the regression step and directly adding the binary images up in STEP 3. We conclude that as the noise present in the image increases more and more performance gain can be achieved by adjusting weights instead of empirically adding the binary images up. This is justified, since more and more distortion occurs from the uniform distribution of weights as the noise levels increase.

Additionally, a clever trick that can be readily used for performance boost with absolutely minimal additional time and space requirements is to pre-calculate the weights for recombination in case of denoising SPN noise. If the noise induced in the image is expected to lie in the range of 0.05 - 0.20, then these weights can be reliably pre-calculated at the time of either generating the image or before sending it over a noisy channel. As can be seen from Table II, the actual distribution of weight remains practically the same and is not very much dependent on small changes in the noise level and on the actual realization of the noise with same noise level in the image. This allows the pre-processing of image at the time the image is generated and later recombination within minimal time overheads.

Also, it is observed that the minimizing objective as defined by Eq.(5) is sufficiently nice and flat to allow for use of local minima in lieu of global minima finding algorithms. Specifically, instead of using methods that search for global minima over all possible space such as Simulated annealing, we can reasonably limit the search space to an appropriate value (depending on the number of thresholds used) and use local minima finding approaches on this smaller space for identical performance results and weight distributions.

V CONCLUSIONS

We conclude by summarizing the three invariances discovered by our work and their possible exploitations which allow us to use regression based weighed recombination of binary images as a method for extending CA to grayscale images:

• •

Invariance to subsampling: This allows us to randomly uniformly sample a $\eta$% of uncorrupted pixels for use in regression for finding the weights yielding a corresponding speedup in the process. $\eta$ can be taken to be as low as 1% for large images (512x512 or larger) without any practical deterioration of performance.

• •

Invariance to actual noise realization : For narrow ranges of noise level between 0.05 to 0.2, the actual distribution of weights can be pre-calculated and transmitted alongwith the image. This facilitates practically zero overhead in time for the end user using the algorithm along-with allowing use of CA for gray-scale image processing in realtime.

• •

Equivalence of Local and Global Minima: This allows us to significantly cut down on the search space of possible weights. The algorithms for finding the local minima can be used instead of global minimal search algorithms such as Simulated Annealing, further reducing the time for the one-time per image generation of weights.

Further optimization can be achieved by intializing the weights to an even better start or by developing a clever method for determining the thresholding weights and thereby, reducing the number of binary images that need to be recombined. Moreover, the use of inherent parallel structures of CA can be exploited to reduce the overall time overhead for application of CA to both binary and gray-scale images.

VI ACKNOWLEDGMENT

The author would like to express his gratitude towards SURGE (Student Undergraduate Research Grant for Excellence) programme offered by IIT Kanpur for the grant and the opportunity to pursue the project. It would not have been possible without the kind support and help of many individuals and the staff of the dept. The author would like to extend his sincere thanks to all of them.