1 Quantization Effects in Tomographic Reconstruction

A Survey of the Effects of Quantization on Image Quality in Tomographic Reconstruction Nikhil Subramanian Electrical Engineering, University of Washington, Seattle, WA 98195, USA [email protected]

Keywords: Medical image processing, tomographic reconstruction, filtered back projection, iterative reconstruction, quantization studies

Abstract. Image reconstruction systems in both emission (PET) and transmission (CT) tomography are moving toward iterative techniques that accurately model the imaging process. Even though these techniques are more involved than analytical methods, they are attractive because they recover better quality images from noisy data. Traditionally, compute intensive algorithms are accelerated on custom hardware platforms using fixed point representation of data to achieve maximum performance. If the bit widths are carefully chosen, the quantization introduced by fixed precession is imperceptible. Quantization noise is not a quality limiting factor in tomographic systems based on analytical techniques such as Filtered Back Projection (FBP). However, in iterative techniques, fixed point implementations may suffer from compounding quantization noise that grows over time. While the quantization effects in FBP are well understood, to date, the author is unaware of any conclusive study on the effects of quantization noise in iterative reconstruction. This paper presents an overview of quantization effects as it applies to FBP and motivates the need to study these effects in iterative reconstruction techniques.

I. INTRODUCTION Tomographic reconstruction is the process of creating cross-sectional images from emission or transmission data acquired by a scanner. Kinahan et al. [1] suggest that apart from PET and X-ray CT, these principles apply to a variety of other application domains ranging from radio astronomy to electron microscopy. As a result, there has been considerable interest in evolving efficient and accurate techniques to perform the reconstruction. A well researched and widely used method of tomographic reconstruction is the Filtered Back Projection (FBP) algorithm which inverts a discrete version of the radon transform. FBP models the detector data simply as line integrals through the object placed in the scanner’s field of view. This assumption allows the exact mathematical reconstruction through FBP to be posed in a simple framework. While FBP is popular because it is relatively simple to compute, the acquired data in tomographic systems are subject to various random phenomenon and irregularities which FBP cannot account for. In order to employ a “closer to real” model of the acquisition process, iterative techniques are employed. From a computation standpoint, these techniques involve repeated transformations between the image space and the projection space in contrast to FBP which makes just one transform of the projection data into the image space (with associated filtering). As a result, depending on the number of iterations used, iterative techniques can be orders of magnitude more computationally demanding than FBP.

_______________________________________________

This paper is submitted in partial fulfillment of course requirements for RADGY 508A – Physical Aspects of Medical Imaging (Winter 2009) run by Prof. Brent Stewart.

In FBP, the back projection step accounts for 50% to 70% of the total execution time [2]. In iterative techniques, back projection and its closely related converse, forward projection (also known as reprojection) can account for as much as 60% to 80%

Nikhil Subramanian is with the Applied Computing Machines and Emulators (ACME) Lab, Department of Electrical Engineering, University of Washington, Seattle WA 98195, USA.

1

2 Quantization Effects in Tomographic Reconstruction overall image quality compared to other factors in the CT system.

of the execution. (It is higher for iterative techniques because filtering is not performed at each stage). As a result hardware acceleration of the back projection and the forward projection step has been the focus of numerous studies [3-8].

Lalush and Wernick [3] argue that principal trade-off between iterative techniques and FBP is one of accuracy versus efficiency. The assertion is that iterative methods will provide better image quality at the cost of increased computational complexity. This basically suggests that at the algorithm level, we make the tradeoff that lets us decide if we want more performance or more quality. While this is true to the first order, it does not take into account quantization errors. As iterative techniques are performance constrained it is likely that they will be forced to use fixed point implementations. This opens up the possibility of compounding quantization noise if we choose smaller bit widths for faster performance. Hence, there is a second level, the implementation level, at which we can tradeoff performance for quality. Either level, algorithm or implementation, in isolation does not reveal the complete picture and only paying attention to one may lead to erroneous conclusions about the actual tradeoffs in the system. Further, choices at one level may impact choices in the other.

When algorithms are simulated or implemented on general purpose processors, the data is usually represented as floating point numbers that have high dynamic range and precision. However, in custom ASIC or reconfigurable hardware implementations, one of the first optimizations made is conversion of the data path to fixed point. The hardware designers optimize the system by using the fewest bits that produce the required reconstruction quality. The motivation is that a fixed point implementation can offer between 5x to 25x better performance than its floating point counterpart. Also, smaller data widths result in smaller designs that consume less power and have faster execution times. Xue et al. [6] demonstrated that back projecting a 256x256 image from 165 equiangular projections having 512 detectors was 21x faster if implemented using 32 bit fixed point on an Nvidia GPU (Graphics Processing Unit) when compared to floating point on a CPU. Further, a 16 bit fixed point implementation on the same GPU was 44x faster than the CPU proving that both the adoption of fixed point and the move towards smaller bit widths is desirable from a purely performance standpoint. It should be noted that bulk of the above performance gain comes from the parallelism in the GPU implementation and not just the conversion to fixed point. However, smaller fixed point bit width allows us to accommodate higher levels of parallelism in the system. The RMS error in moving from the floating point representation to 32 bit fixed point increased by .07% which is negligible. However the RMS error in moving from floating point to 16 bit fixed point increased by 2%3%. Depending on the desired SNR properties in the system, even this might be acceptable in the FBP case as 3% introduced error gives a 44x speedup.

Two scenarios arise from the above discussion. Iterative reconstruction might be constrained to use only high precision fixed point or floating point which will limit its computational efficiency compared to FBP. Or, quantization might be a significant source of noise in the images produced by iterative techniques reducing their accuracy over FBP for a fixed performance gap. To state it differently, if designers were to accept a certain performance gap that would arise from having to implement a more intensive iterative technique, they might still not realize the image quality increase over FBP they expect because quantization effects might be more dominant in iterative techniques than in FBP. To date there has been no thorough investigation of these quantization effects in iterative algorithms to conclusively state if the above observation holds true or not. A reason for this is that iterative techniques aren’t widely implemented in custom hardware yet. Most reported results such as Yokoi et al. [9], come from CPU simulations that use floating point precession and take 16-18 hours to compute the images. Given the above factors there is merit in the study of quantization effects in iterative techniques.

It is clear from the above discussion that from a hardware implementation standpoint, there are two knobs at the disposal of the designer. He can go ahead and dial up the precision knob and pay a performance penalty or he might turn up the performance knob and take a quality hit. While these tradeoffs are constantly made in the actual implementation of clinical systems, in the world of algorithm development for diagnostic radiology, the quantization effects are ignored because they conventionally have a much smaller impact on

The reminder of this paper is organized as follows. Section II provides an overview of FBP and discusses the performance of systems designed by Leeser [4] and others [5-7]. It also presents Leeser’s framework

2

3 Quantization Effects in Tomographic Reconstruction Table I adapted from Kachlerieβ Kachlerie et al. [8] below shows performance figures (corrected for process generation) from several custom hardware implementations of FBP reconstruction. reconstruction It also shows the bit-width width of the data path employed.

to estimate quantization effects. Section III talks about iterative techniques and introduces a simplified system to try to tease out quantization effec effects. It also proposes a scheme based on Leeser’s work to estimate quantization. Finally a discussion is made of the findings and future directions are proposed.

Table I

II. FILTERED BACK PROJECTION The reconstruction process in the FBP algorithm is relatively straightforward as shown in Fig (1). The scanner acquires projections of the object from various angles. These projections can be represented in the form of a sinogram which is essentially a matrix of detector values for every acquisition angle. angle The sinogram ram is filtered using a ramp filter and subsequently back projected. The filtering step prepre corrects for the oversampling in the center of the Fourier space that occurs during back projection. The back projection is a compute intensive step that involves determining etermining the contributions of each projection to each pixel in the image. Further, an image pixel might be detected by two detectors and hence interpolation of adjacent detector values is required. The algorithm has a complexity on the order of O(n3). Where ere n is the number of pixels in the resultant image.

Group

Type

Leeser et al. [4]

i09

FPGA (Virtex -2)

Agi et al. [5]

i12

ASIC (1um)

.7 ms

Xui et al. [6]

f32

CPU

7.13 s

i32

FPGA (Altera )

273 ms

i32

GPU (Nvidia GF 7800)

295 ms

i16

GPU (Nvidia GF 7800)

143 ms

i16

MPPA

Ambric [7]

Hardware

Time 42 - 65 ms

54 ms

It can be seen that the custom hardware platforms have consistently outperformed the CPU benchmarks by 25x to 1000x. 0x. Further it is noted that low bit width correlates with faster performance. In order to understand the effect of choosing low bit widths on image quality we pick the implementation by Leeser et al. [4]. Leeser performed extensive software simulation of the tomographic process to determine how much quantization can be tolerated by her system. The idea was to have a simulation harness that performed both floating point and fixed point calculation at every stage along the data path. The errors due to quantization at each stage were measured and this allowed for a better understanding of which computations affect quantization more. It is clear from [4] that a fixed data path width is not required throughout the reconstruction computation. computation The system is much more sensitive to quantization on certain operations than on others. Figure 2. shows s a detailed flowchart of the simulation process that was used. The various numbered paths represent different stages of computation being quantized. For example the path labeled 1 represents a pure floating point reconstruction. Path 2 represents the quantization q of just the sinogram data and 4 represent the quantization of the interpolation factor etc.

Fig. 1. FBP based CT system.

3

4 Quantization Effects in Tomographic Reconstruction

Fig. 2. Detailed flowchart of Leeser’s simulation process [4] The floating point data path (1) can be considered best case when comparing and evaluating the performance of fixed point. This is because floating point has 30,000 times less quantization noise than fixed point [10]. Leeser observes that in a system with n-bit accurate detectors, n bits can be used to represent the sinogram data. This results in an error of less than .001% compared to floating point data.

can be configured either as two 9-bit multipliers or one 18-bit multiplier. If Leeser had chosen 10 bits to represent the filtered sinogram, the one extra bit would have caused her to use up twice as many multiplier blocks in her system making it inefficient. These sorts of tradeoffs have to often be made at the implementation level and any absolute guidelines for the designer in terms of quality can be useful. For example a constraint like “at no stage can the relative error exceed .1%” could be a useful guideline for the hardware designer who can then figure out how she might tradeoff quality for performance.

Figure 3 below, shows a plot of bit width versus error relative to floating point implementation for path 3(quantization of filtered sinogram) for various phantom images.

It is relevant to point out here that overall CT image quality is determined by several factors most of which have to do with physical aspects of the device. High precession cannot make up for inherent limitations of the reconstruction algorithm. Similarly even the most ingenious algorithms will still be challenged by noisy detection systems that have secondary quantum sinks or patient motion during the scan. Bushberg et al. [11] list the various factors that affect the spatial resolution and contrast resolution of CT systems. 11 out of the 13 factors that affect spatial resolution have nothing to do with the reconstruction algorithm and are dependent on physical factors such as detector aperture and focal spot size. Quantization is not even listed as a factor affecting spatial or contrast resolution. While it is true that high precession data paths cannot increase image detail beyond what the system is physically capable of acquiring, low precession can lead to the squandering of some of the gains that a well designed CT system affords. Considering that the physical aspects of the device are usually the hardest to get right, this is usually unacceptable.

From the figure it is clear that 7 or 8 bits is too few to represent the filtered sinogram as it results in large relative errors. 9 bits is better while 10 or 11 provide almost ideal performance. In Leeser’s system there was a compelling reason to choose 9 bits because the Xilinx FPGAs have hard coded multiplier blocks that

4

5 Quantization Effects in Tomographic Reconstruction might do to this system, it is useful to think of a theoretical implementation that unrolls the entire operation. This unrolled version essentially takes the feedback system and makes it a long feed-forward chain. Consider 5 iterations of the system. We could think of it either as 4 blocks running 5 times in sequence or as 20 blocks running once in sequence.

III ITERATIVE RECONSTRUCTION Iterative reconstruction techniques represent a class of algorithms that successively improve an estimate of the unknown image by repeatedly correcting the estimate by comparisons with the measured data and models of system behavior. It is capable of accounting for the fact that the data received by the detectors is affected by probabilistic variations that arise from physical effects in the system. There are a number of iterative algorithms that can incorporate a variety of data and system models to provide better results. For the purposes of this discussion we will consider a simple framework to iterate between the projection space and the image space keeping in mind that any real implementation will have normalization and possibly filtering stages that are essential to make the algorithm work.

This above view indicates that if there was one step that added quantization noise in the system, over the 5 iterations, we could add as much as 5 times the quantization noise. It is clear how the small noise injected due to quantization that could be ignored in FBP can quickly get out of hand in iterative techniques for large numbers of iterations. We now consider a framework that will allow us to quantify and measure the injected quantization noise. Again we make the assumption that the floating point reconstruction has perfect fidelity compared to fixed point for reasons mentioned earlier. The flowchart shown in Figure 5 shows the simulation system that can be employed. The path color coded in green is the floating point reconstruction path. The blue path and brown path represents a quantization error introduced in the back project and forward projection step respectively. The red path indicates quantization errors introduced in both forward and back projection. The difference between the green path and the blue path is identical to path 4 in Figure 2 for a single iteration. The results from Leeser et al. for path 4 are shown below in Figure 4.

While this framework by itself is incapable of reconstructing any images, it represents the meat of the problem in any iterative system. From a computation standpoint, it accounts for nearly 80% of the runtime and roughly the same fraction of the design time. The sequence of operations in a simple iterative framework is presented below. This framework can be thought of as a simplified implementation of a Maximum Likelihood – Expectation Maximization (ML- EM) system [12]. ி௢௥௪௔௥ௗ ௣௥௢௝௘௖௧

(1) (X,Y)estimate ሱۛۛۛۛۛۛۛۛۛۛۛۛۛۛۛۛሮ (S,ϕ)estimate (2) (S,ϕ)ratio =

(3) (S,ϕ)ratio

ሺௌ,థሻ௘௦௧௜௠௔௧௘ ሺௌ,థሻ௠௘௔௦௨௥௘ௗ

஻௔௖௞ ௣௥௢௝௘௖௧

ሱۛۛۛۛۛۛۛۛۛۛۛۛۛۛۛۛሮ (X,Y)correction

(4) (X,Y)new estimate = (X,Y)estimate*(X,Y)correction Where, (X,Y) represents the image space values and (S,ϕ) represents sinogram space values. We move between (X,Y) and (S, ϕ) using the forward and back projection operation (1) and (3) which are complex multi-step operations on the order of O(n3) as mentioned earlier. In comparison steps (2) and (4) are computationally trivial. The algorithm proceeds by repeating these steps over and over until the estimate of the image is closest to the image that produced the measured data. In order to assess what quantization

Fig. 4. Quantization in back projection interpolation

5

6 Quantization Effects in Tomographic Reconstruction

Fig. 5 Flowchart of simulation framework framework to estimate and measure quantization noise We see from figure 4 that the quantization of the interpolation operation during back projection in a single iteration introduces 0.012% error relative to floating point forr a 3 bit interpolation factor. While this was negligible in FBP, this error can grow to 1% in 100 iterations of the system. Further, from the flowchart in figure 5, we see that the red path has 2 stages of such quantization and that can double the error.

higher bit-width width may actually increase the performance because at a global level, the algorithm can converge faster with the increased precession even though each loop of the iteration may take longer. The two curves that represent performance versus bit-width width from an implementation standpoint (optimizing imizing each loop of iteration to run as fast as possible) and an algorithm standpoint (optimize the overall system to run as fast as possible with fewest number of iterations) may diverge. In this case there will still be an inflection point at the intersection of these two curves that will be the optimal value of data-path path bit width for the system.

There is the possibility that the algorithm can be structured to cancel the effects of quantization in subsequent stages instead of accumulating them. It is not clear if such a solution is possible. Even if it is, for a given convergence criterion, quantization quantiz will increase the time to converge because the values oscillate about the correct values values. This might introduce another tradeoff between performance and chosen bit width that is counter-intuitive. intuitive. A slightly

The above discussion shows that the factors affecting the performance, accuracy and runtime of the iterative reconstruction methods as involved as the methods thods themselves and ignoring quantization effects as negligible is not be accurate.

6

7 Quantization Effects in Tomographic Reconstruction [4] M. Leeser, S. Coric, E. Miller, H. Yu, and M. Trepanier, “Parallel–beam backprojection: An FPGA implementation optimized for medicalimaging,” Proc. of the Tenth Int. Symposium on FPGA, Monterey, CA,pp. 217–226, Feb. 2002.

IV CONCLUSION The motivation to perform a detailed and careful study of the effects of quantization on iterative reconstruction was presented. A simulation framework to measure the errors at various stages and obtain a better understanding of the implications was also presented. This study makes the following important observations. Fast implementations of reconstruction algorithms invariably use fixed point arithmetic that introduces a small amount of quantization noise into the image. Iterative methods have the potential to compound quantization errors and it is wrong to assume that these errors are insignificant as in the case of FBP. Low precession data paths might give up some of the gains of a well constructed system if careful attention is not paid to quantization effects in the reconstruction process. Care must be taken to avoid these loses in image quality. Iterative methods might throw off hardware designers by counter-intuitive tradeoffs that allow higher precession systems to perform faster even if the individual stages are slower than a lower precession system that has very fast compute stages. All these factors need to be well understood as we migrate from simulation to custom hardware implementations of iterative algorithms.

[5] Agi, I., Hurst, P.J., and Current, K.W., “A VLSI architecture for high-speed image reconstruction: considerations for a fixed-point architecture,” Proceedings of SPIE, Parallel Architectures for Image Processing, vol. 1246, 1990, pp. 11-24. [6] X. Xue, A. Cheryauka, and D. Tubbs, “Acceleration of fluoro–CT reconstruction for a mobile C–arm on GPU and FPGA hardware: A simulation study,” SPIE Medical Imaging Proc., vol. 6142, pp. 1494–1501, Feb. 2006. [7] Ambric Am2045 CT Backprojection Acceleration White Paper [8] Kachelrieb, M.; Knaup, M.; Bockenbach, O., "Hyperfast Parallel¿Beam Backprojection," Nuclear Science Symposium Conference Record,2006. IEEE , vol.5, no., pp.3111-3114, Oct. 29 2006-Nov. 1 2006 [9]: T. Yokoi, H. Shinohara, T. Hashimoto, T. Yamamoto, and Y. Niio, Implementation and Performance Evaluation of Iterative Reconstruction Algorithms in SPECT: A Simulation Study Using EGS4 - Proceedings of the Second International Workshop on EGS, 8.-12. August 2000, Tsukuba, JapanKEK Proceedings 200-20, pp.224-234

V REFERENCES [1] P. E. Kinahan, M. Defrise, and R. Clackdoyle, “Analytic image reconstruction methods,” in Emission Tomography: The Fundamentals of PET and SPECT, pp. 421–442, Elsevier Academic Press, San Diego, Calif, USA, 2004.

[10] Steven W. Smith, "Digital Signal Processing: A Practical Guide for Engineers and Scientists" SoftCover, 2002 ISBN 0-7506-7444-X.

[2] Nicolas GAC, Stéphane Mancini, Michel Desvignes, and Dominique Houzet, “High Speed 3D Tomography on CPU, GPU, and FPGA,” EURASIP Journal on Embedded Systems, vol. 2008, Article ID 930250, 12 pages, 2008.

[11] Bushberg, Seibert, Leidholdt and Boone, "the Essential Physica of Medical Emaging, Second Edition, Lippincott Williams and Wilkins, Hardcover2002. ISBN 0-683-30118-7

[3] David S. Lalush and Miles N. Wernick, “Iterative Image Reconstruction” in Emission Tomography: The Fundamentals of PET and SPECT, pp. 443, Elsevier Academic Press, San Diego, Calif, USA, 2004.

[12] Hutton, Brian F. An Introduction to Iterative Reconstruction. Alasbimn Journal 5(18): October 2002. Article N° AJ18-6.

7