1. A Parallel Algorithm for Hardware Implementation of Inverse Halftoning
Umair F. Siddiqi1, Sadiq M. Sait1 & Aamir A. Farooqui2
1Department of Computer Engineering
King Fahd University of Petroleum & Minerals, Dhahran 31261, Saudi Arabia
2Synopsys Inc.
Synopsys Module Compiler, Mountain View
California, USA

2. Analog halftoning
The process of rendition of continuous tone pictures on media on which only two levels can be displayed.
The size of dots are adjusted according to the local print intensity.
When looked at a distance it gives the impression of the original picture.

3. Digital halftoning
In digital halftoning the input of the system is a grey-level image having more than two levels for example, 256 levels and the resulting image has only two levels.
The halftone image is comprised of zeros and ones but gives the impression of the original image from a distance.

4. Inverse halftoning
Inverse halftoning is the reconstruction of continuous tone picture (e.g. 256 levels) from its halftoned version.
The input to an inverse halftoning system in an image that consists of zeros and ones and output is an image in which each pixel have value from 256 gray-levels.
Inverse Halftoning finds application in image compression, printed image processing, scaling, enhancement, etc.
Inverse halftoning can be for color images but we are concerned with gray-level images and their halftones.

5. Example of Inverse Halftoning
Halftone Image Inverse Halftone or grey-level image

6. Demonstration of our Inverse halftoning algorithm
The next few slides can show how inverse halftone operation is being performed in our algorithm.

7. Lookup Table (LUT) based Inverse Halftone operation
The Lookup Table (LUT) method proposed by Mese and Vaidyanathan is used for inverse halftone operation.
The LUT method uses a template “19pels” to select pixels from the neighborhood of the pixel that is going to be inverse halftone.
This “19pels” then goes into a LUT which compares the “19pels” with its stored values and returns a gray-level for the input “19pels”.

8. “19pels” Template 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
The pixel numbered 0 is the one going to be inverse halftoned
This pattern is associated with each pixel that is to be inverse halftoned

9. Demonstration of LUT inverse halftoning

10. This is the first “19pels” selected

11. This is the second “19pels” selected

12. This is the third “19pels” selected

13. This is the fourth “19pels” selected

14. Our modification to LUT based Inverse Halftoning

15. Problem of parallel LUT inverse halftone operation
The LUT method uses one Lookup table that contains inverse halftone values for all “19pels” that are obtained through training set of halftones of standard images.
To fetch parallel inverse halftone values of more than one 19pels we need to implement multiple copies of the LUT !

16. Our approach to parallel LUT inverse halftoning
The single large LUT has been divided into many Smaller LUTs (SLUTs).
Now more than one 19pels can fetch its inverse halftone value from a separate SLUT independent to other parallel 19pels.
Next problem is to develop a method to send incoming 19pels to separate SLUTs.

17. Method to distinguish 19pels from each other
The task to send many incoming 19pels to their separate SLUTs has been accomplish by defining an operator over 19pels.
This operator is called Relative XOR Change (RXC).
When all incoming 19pels are operated through this operator they convert into distintguish values in the range of -t to +t, where t = 19 in our case, but it could be any random integer within a suitable range with respect to total number of SLUTs and hardware complexity.

18. Demonstration of RXC operation

19. RXC over gray-level halftones I
Corresponding halftone obtained through Floyd and Steinberg Error Diffusion Method

20. RXC over gray-level halftones II
Corresponding halftone obtained through Floyd and Steinberg Error Diffusion Method

21. Magnified look at the halftones I
Gray-level 210
Gray-level 130
Halftone shows no column-wise periodicity among dots over small 19pels regions
Halftone shows column-wise periodicity among dots over small 19pels regions

22. Magnified look at the halftones II
Gray-level 120
Portion of the halftone from image Boat
Halftone shows no periodicity among dots over small 1D 19pels regions
Halftone shows no periodicity among dots over small 1D 19pels regions

23. Behavior of RXC over Grey-level halftones
Gray level 210
Gray level 130
NOT Periodic Vibratory Response
Periodic Vibratory Response
Halftones obtained through Floyd & Steinberg Error Diffusion Method

24. Representation of RXC values on number line
Periodic Vibratory Values
RXC values to be used in SLUT access are calculated by adding the RXC to the RXC of the previous “19pels”
That is:
RXC for SLUT of Pn (Slut)=
RXC of Pn-1 +
RXC of Pn-2(n)
From the number line we can see that adding RXC over previous values gives zero or constant result, therefore, we need NOT periodic vibratory response from RXC operator.

25. NOT Periodic Vibratory RXC Operator
The operator RXC has been defined that is simple to implement in hardware as well as gives NOT periodic vibratory response over most of the gray levels from 0 to 255.
We have assumed that a gray level image is a composition of many gray levels and obtaining the performance of RXC over individual gray levels can give a clue about its performance on images.
This assumption is found to be correct in simulation results.

26. RXC Operator for Pn
Pn-1= “19pels” with the pixel 0 at position (row,col-1);
Pn= “19pels” with pixel 0 at position (row,col);
xor_1= XOR(Pn-1, Pn );
Magnitude of RXC= |RXC|= Number of Ones(xor_1);
Sign of RXC= sgn(RXC)= + when |Pn| > |Pn-1|
- when |Pn| < |Pn-1|
Note: pixel 0 is the one that is to be inverse halftoned

27. Parallel application of RXC

28. Development of parallel table access algorithm with RXC
The addition of Slut values from previous pixels simplifies the hardware design

29. Formal Algorithm

30. Simulation
The algorithm is implemented in MATLAB the performance and quality of inverse halftoning is estimated.
We assumed LUT inverse halftone operation to be ideal.
The simulation results show the quality loss with respect to original image that occurred in distribution of parallel “19pels” to different SLUTs through RXC.
This pixel loss is compensated through replicating gray level values from the neighbors.

31. Sample Image I
peppers
PSNR=

32. Sample Image II
lena
PSNR=

33. Sample Image III
mandrill
PSNR=

34. Quality of inverse halftones
Image
Halftone Algorithm
%pixel coverage w/o pixel compensation
PSNR with pixel compensation
Boat
FS ED
Clock
Peppers
GN ED
EG ED

35. Hardware Implementation
This section shows the hardware implementation of the proposed parallel algorithm in terms of block diagrams.
The specification of the hardware design is:
Parallel Pixels to be inverse halftone= n= 15
Number of SLUTs= 19

36. Two Blocks of hardware Implementation
The hardware system can be divided into two blocks:
RXC and modulus operators
19pels to gray-level decoders

37. System Block diagram

38. RXC and modulus operators
RXC and modulus operators components are responsible for the following tasks:
Input: 19pels Output: SLUT numbers Slut
Accept 19pels from the halftone image and assign a sequence number to each entered 19pels.
Perform RXC operation on all 19pels.
Add the Slut value of the 19pels that has preceding sequence number to the current result.
Then take mod of the current result with a fixed number i.e. 19 in our case to obtain Slut value for the current 19pels.
The above three steps are pipelined so new 19pels are coming in while the current 19pels are in process.

39. RXC and modulus Block Diagram
RXC calculation for 19pels Pn
Pn-1 and Pn are two 19pels among all 19pels to be inverse halftoned in parallel.
Slut is the Smaller LUT number where the concerned 19pels should go to fetch its inverse halftone value.

40. Hardware Design of RXC and modulus Operator
The next slides can show the hardware design of RXC operator for a 19pels pattern named Pn with the following parameters:
Parallel pixels to be inverse halftoned at a time= 15
Total number of SLUTs= 19, therefore, Slut is from 0 to 19.

41. The figure shows bit-to-bit XOR of 19pels Pn and Pn+1

42. Addition of Number of ones in XOR result to obtain |RXC|

43. Comparing of |Pn| and |Pn+1| to obtain sign(RXC)

44. Determination of Slut from RXC

45. Block diagram showing gray-level decoding process

46. Routing of a 19pels to 5th SLUT

47. Routing of a 19pels to 16th SLUT

48. Routing of a 19pels to 3rd SLUT

49. Routing of a 19pels to 17th SLUT

50. 1p x 19p DEMUXi(i=2)

51. 19p x 1p MUXn(n=16)

52. SLUTi(i=16)

53. Method to generate contents of SLUT
The algorithm is applied on images in a training set and Sluts values are obtained.
The 19pels then placed in the SLUT given by the corresponding Slut value.

54. Properties of SLUTs
The SLUTs were developed using training set composed of FS ED halftone images of Boat and Peppers of size 256x256-pixels.
The size of one SLUT is found to be 2.5K entries .
The summation of entries in all 19 SLUTs comes to be 42.6K.
The size of LUT in single LUT method is 9.86K entries, however, if the single LUT method is implemented multiple times for 15 parallel pixels the total size could become 148K entries.
In this way, our method can provide 3.5 times decrease in lookup table size over single LUT based method.

55. Conclusion
A method to parallel inverse halftone 15-pixels at a time is proposed and implemented.
The results show that it can provide 3.5 times decrease in lookup table size over single LUT based method if implemented for parallel inverse halftone operation.