2D/3D Image Registration on the GPU

Transcription

1 2D/3D Image Registration on the GPU Alexander Kubias 1, Frank Deinzer 2, Tobias Feldmann 1, Stefan Paulus 1, Dietrich Paulus 1, Bernd Schreiber 2, and Thomas Brunner 2 1 University of Koblenz-Landau, Koblenz, Germany {kubias tfeld stpauli paulus}@uni-koblenz.de 2 Siemens Medical Solutions, Forchheim, Germany frank.deinzer@siemens.com Abstract. We present a method that performs the rigid 2D/3D image registration efficiently on the GPU. As one main contribution of this paper, we propose an efficient method for generating realistic DRRs that are visually similar to X-ray images. Therefore, we model some of the electronic post-processes of current X- ray C-arm-systems. As another main contribution, the GPU is used to compute eight intensity-based similarity measures between the DRR and the X-ray image in parallel. A combination of these eight similarity measures is used as a new similarity measure for the optimization. We evaluated the performance and the precision of our 2D/3D image registration algorithm using two phantom models. Compared to a CPU+GPU algorithm, which calculates the similarity measures on the CPU, our GPU algorithm is between three and six times faster. In contrast to single similarity measures, our new similarity measure achieved precise and robust registration results for both phantom models. Key words: Image Registration, DRR Generation, GPU 1 Introduction As mentioned in [1], image registration is a very common problem in medical image processing and, thus, automatic image registration is a very important component in current medical imaging systems [2]. In 2D/3D image registration, a preoperative volume is registered with an intraoperative X-ray image. Thus, the preoperatively acquired volume can be used for intraoperative therapy guidance [3]. Intensity-based methods for the 2D/3D image registration consist of two parts, namely the DRR generation and the computation of a similarity measure between the DRR and the X-ray image. We restrict ourselves to rigid 2D/3D image registration in which six parameters (three translations and three rotations) must be estimated. Because of the increasing performance of GPUs (Graphical Processing Units) in the last fifteen years, the GPU has become an attractive target for image registration algorithms. In [4] the regularized gradient flow algorithm has been implemented on the GPU for non-rigid 2D/2D-registration. This algorithm has been extended in [5] for 3D/3D image registration, likewise by using the GPU. Several approaches were developed to perform the 2D/3D registration on the GPU. The 2D/3D-registration consists of the generation of digitally reconstructed radiographs (DRRs) and the computation of similarity measures [6]. Some of these approaches like [7] and [8] generated only the DRRs on the GPU, while the similarity measures were still computed on the CPU.

2 2 Lately, some approaches like [9] implemented both parts of the 2D/3D registration on the GPU and achieved huge performance speedups. In this paper we present a method that performs the rigid 2D/3D image registration efficiently on the GPU. Both parts of our registration algorithm, i.e. the DRR generation and the computation of the similarity measure, are executed on the GPU. Our method for generating DRRs is based on the GPU-based volume rendering algorithm that was published in [10]. We also use the improvements for this algorithm that were mentioned in [11]. As one main contribution of this paper, we extend the algorithm in [11] so that it produces realistic DRRs that are visually similar to X-ray images. In this paper we use the term realistic or visually similar if the intensities of the DRR and the X-ray image are nearly the same. By increasing the similarity of DRRs and X-ray images, the image registration will be simplified. The similarity can be increased because we model some of electronic post-processes of current X-ray C-arm-systems in our method. After accomplishing the DRR generation, the GPU is used to compute eight intensity-based similarity measures between the DRR and the X-ray image in parallel. Instead of using only single similarity measures for the registration, we use a combination of the eight similarity measures to ensure precise and robust registration results. In section 2 we describe our 2D/3D image registration method that is executed on the GPU. We describe the realistic DRR generation and the parallel computation of eight similarity measures on the GPU in this section. In section 3 we show and discuss the results of our implementation. Finally, in section 4 we conclude and present some ideas for our future work. 2 2D/3D Image Registration on the GPU Image registration is a very common problem in medical image processing. In medical settings images of the same modality or of different modalities are often needed in order to provide precise diagnoses. However, a meaningful usage of different images is only possible if the images were correctly aligned before. Therefore, a image registration algorithm is deployed. In 2D/3D image registration, a preoperative volume (e.g. CT or MRT) is registered with an intraoperative X-ray image. In this paper we restrict ourself to rigid image registration where the volume can only be translated and rotated according to three coordinate axes. This transformation is given by the parameter vector x = (t x, t y, t z, r x, r y, r z ). Thereby, the parameters t x, t y, t z represent the translation in mm along the X-, Y- and Z-axis, whereas the parameters r x, r y, r z belong to the Rodrigues [12] vector r = (r x, r y, r z ). As mentioned before, the image registration algorithm consists of two parts, i.e. the DRR generation and the computation of a similarity measure between the DRR and the X-ray image that should be aligned to the volume. After translating and rotating the volume, the DRR I DRR (x) is produced from the volume according to the current transformation x of the volume. The DRR is generated by the method, which is described in subsection 2.1. Afterwards, the DRR I DRR (x) is compared to the X-ray image I FLL by applying a similarity measure S according to (1). The used X-ray image I FLL was

3 3 acquired by a X-ray C-arm-system before. S(I FLL, I DRR (x)) (1) By using a certain optimization technique, the similarity between the DRR and the X- ray image will be increased according to (2) until the optimal parameter vector x is found. The method for computing the similarity measure is described in subsection 2.2. Our optimization technique consists of a combination of the global optimizer Adaptive Random Search [13] and the local optimizer Best Neighbor [14]. x = argmax S(I FLL, I DRR (x)) (2) x 2.1 Realistic DRR Generation Intuitively, it is easier to align the DRR and the X-ray image, if they are visually similar. If the DRR is not similar to the X-ray image, either the DRR or the X-ray image must be adapted to the other image by executing post-processing algorithms. Instead of costly post-processing algorithms, we develop a method for the realistic DRR generation. In this method we model some of the electronic post-processes that are executed in current X-ray C-arm-systems. However, we restrict ourselves to those electronic postprocessing algorithms that significantly affect the intensities and the contrast of the X-ray image. Hence, in our method the DRRs are created in a similar way as in current X-ray C-arm-systems and, thus, the DRR will be visually similar to X-ray images, without the need for post-processing algorithms. Theoretical Background The value of a pixel in an X-ray image depends on two factors, namely the intensity of the incident X-rays on the detector and the following electronic post-processes [6]. In contrast to [6], some of these electronic post-processes are also integrated in our method for the realistic DRR generation. The intensity J of the incident X-rays depends on three factors, i.e. the initial intensity J 0, the distance between the X-ray source and the detector and the attenuation of the X-rays by the material, through which the X-rays pass [6]. The attenuation coefficients µ i describe the percentage by which the X-ray is attenuated in the passed material. For instance, water has the attenuation coefficient µ Water = 0.25cm 1 [15]. In the computer tomography sector Hounsfield Units (HU) [15] are used in order to specify the attenuation of the passed tissue. HU values are often in the domain [ 1000; 7000] [15]. For instance, water has 0 HU. They can be computed from the attenuation coefficients µ by HU = µ µ Water µ Water (3) If the X-ray passes the distance d through a homogeneous object with the attenuation coefficient µ, the initial intensity J 0 is attenuated to the intensity J J = J 0 e µd. (4) However, the human body is not a homogeneous object. It can contain several kinds of tissue with different attenuation coefficients µ i. Additionally, each kind of tissue

4 4 has a certain thickness d i. The attenuated intensity J can be computed correctly and approximately J = J 0 e dr 0 µds J0 e P i µ i d i. (5) If the volume consists of a equidistant grid of discrete voxels and each voxel has the same size, the computation of the attenuated intensity J can be simplified to J = J 0 e P i µ i d. (6) After the X-rays reached the detector, the intensity J(x, y) can be measured at each point (x, y) of the detector. Hereon, the measured intensities J(x, y) will be converted into gray level values by executing some of the electronic post-processes of the C-armsystem. Thus, in the following we model some of these electronic post-processing steps of current C-arm systems. Firstly, the measured intensities J(x, y) must be normalized, so that their mean value corresponds to a given desired value J desired. Thereto, in the inner circle or rectangle Ω of the DRR the average of Ω grey values in Ω is computed J = 1 Ω (x,y) Ω J(x, y). (7) Then, the calculated mean value J must be scaled to the desired value J desired. Therefore, each intensity value J(x, y) is multiplied by a certain factor J mult and, later on, an additive constant J add is added J (x, y) = J desired J(x, y) + J add (8) J = J mult J(x, y) + J add. (9) Finally, the resulting values are inserted in a lookup table γ in order to receive the final gray level values J (x, y) = γ(j (x, y)). (10) Implementation As mentioned before, the intensities of the DRR can be easily computed according to (6). For computing these sums, a ray casting algorithm is well suited. For instance, an efficient GPU-based volume rendering algorithm was described in [10] and was improved in [11]. One of the main contributions of this paper is to extend this algorithm for the realistic DRR generation. In order to execute the DRR generation on the GPU, the volume must already be stored as a 3D texture on the GPU. In [10] the ray casting algorithm consists of four steps that are executed on the GPU one after the other. In our implementation for generating realistic DRRs, we deploy two vertex shaders (in combination with two simple fragment shaders) and one further fragment shader. Additionally, we use the so called Framebuffer Objects. Hence, we are able to render directly to textures. As mentioned in the paragraph about the theoretical background, J mult, J add and γ must be known in order to produce realistic DRRs. Whereas J add and γ are given by the

5 5 Figure 1. DRR and X-ray image of a head and a thorax phantom model specification of the X-ray C-arm system, J mult depends on the current DRR. Thus, the factor J mult must be computed before the realistic DRR generation can start. Therefore, a simple (i.e. non-realistic) DRR is produced from which the mean value J and, thus, the factor J mult can be calculated. For producing the simple DRR, the modeled electronic post-processes are switched off. The simple DRR is generated according to the initial parameter vector x 0 which is near to the optimal parameter vector x. This assumption holds because we want to solve a post-registration problem. After generating the simple DRR, the mean value J can easily be computed using a stencil test. The stencil test masks the inner circle or rectangle Ω of the 2D texture, in which the simple DRR is stored. In order to receive the mean value of Ω, the masked 2D texture is efficiently scaled down by using mipmaps. This is a fast and tricky method in order to average the values in a texture. Subsequently, the minimized 2D texture is downloaded on the CPU where the final mean value is computed. The desired factor J mult can be calculated from J by (9). Finally, the fragment shader can generate realistic DRRs because the input parameters J mult, J add and a 1-D texture with the lookup table γ are provided. The fragment shader for the realistic DRR generation produces an output texture with the realistic DRR and a further output texture, in which the ROI (region of interest) for the DRR is stored. The ROI indicates which part of the DRR is included when the similarity measures are calculated. The automatic determination of this ROI is of major importance as it regards the boundaries of the volume. Thus, the parts outside the volume are not included in the computation of the similarity measures as they could falsify the values of the similarity measures. In Figure 1 the DRR and the X-ray image of a head and a thorax phantom model is shown. Both phantom models were acquired by a X-ray C-arm-system and, thus, a 3D volume was available from which the DRR could be produced. 2.2 Parallel computation of similarity measures on the GPU Theoretical Background For computing the similarity between the DRR and the X-ray image, a similarity measure can be used according to (1). In this paper we use the following intensity-based similarity measures: Sum of Squared Differences (SSD) [6], Sum of Absolute Differences (SAD) [6], Variance of Differences (VOD) [16], Ratio of Image Uniformity (RIU) [17], Normalized Cross Correlation (NCC) [6], Gradient Difference (GDI) [18], Gradient Cross Correlation (GC) [18] and Pattern Intensity (PI) [18]. These similarity measures are efficiently calculated on the GPU as described below. Besides these eight similarity measures, a new similarity measure is created, which calculates the average of the eight similarity measures that are listed above. This new similarity measure is called AESM (Average of Eight Similarity Measures). Before the

6 6 average of the eight similarity measures can be computed, the values of these similarity measures must be assimilated, so that their values are comparable. Thus, each similarity measure has a value between 0 and 1, whereas 0 stands for no similarity and 1 stands for the best similarity. Then, the average of the eight similarity measures can be calculated and used as a new similarity measure. Implementation In spite of the performance of nowadays GPUs, the computation of similarity measures is mostly done on the CPU. For executing this computation on the GPU, it must be adopted to the pipeline architecture of the GPU. Thereby, several problems may arise. Because of the pipeline architecture, shader programs cannot change the values of their input textures and cannot read the values of their output textures. The number of output values is limited as it depends on the number of output textures that are attached to the shader program. Additionally, the number of static and dynamic instructions is limited in a shader program so that complex computations must be split into several shader programs. Some operations like the computation of mean values cannot be efficiently fulfilled inside a shader program. Thus, they are performed by using utilities like mipmaps. Because of the mentioned limitations of current GPUs, the implementation for computing the eight similarity measures is split into three steps: In the first step, several mean values are calculated that are needed for the subsequent computation of the similarity measures. In the second step, the simple intensity-based similarity measures are computed that do not require spatial information, i.e. SSD, SAD, VOD, NCC, RIU. In the third and last step, the more difficult intensity-based similarity measures are computed that do require spatial information, i.e. GDI, GC, PI. DRR in 2-D texture ROI in 2-D texture X-ray image in 2-D texture ROI Shader compute intermediate results for mean values output in 2-D texture output in 2-D texture Mipmapping Shader compute intermediate results for simple similarity measures Mipmapping Shader compute intermediate results for simple similarity measures CPU final final computation of of mean values CPU final final computation of of simple mean similarity values measures output in 2-D texture Mipmapping CPU final final computation computation of of more mean difficult values similarity measures Figure 2. The computation of the similarity measures on the GPU. In order to compute eight similarity measures, three fragment shaders run one after the other. After generating the mipmaps of the output textures of these fragment shaders, the CPU is deployed to compute the final values.

7 7 These computations can easily be performed on the GPU using three fragment shaders that run one after the other. The sequence of these fragment shaders is depicted in Figure 2. All three fragment shaders obtain at least three inputs, i.e. the DRR, the X-ray image and the ROI (region of interest). These three inputs are stored in three separate 2D textures. The textures, in which the DRR and the ROI are stored, are already on the GPU because of the preceding DRR generation. The two last fragment shaders also require the results that were computed by the first fragment shader. The first fragment shader calculates the intermediate results for different mean values in parallel. In order to be able to distinguish the different mean values later on, these intermediate results are stored in the different channels of two output textures. Afterwards, these output textures are efficiently scaled down by using mipmaps. The resulting small textures are downloaded on the CPU where the final mean values are computed. These mean values are used as input values amongst others for the subsequent fragment shaders. S SSD (I FLL, I DRR ) = 1 M (i,j) M (I FLL (i, j) I DRR (i, j)) 2 (11) The second fragment shader calculates the intermediate results for the five different similarity measures SSD, SAD, VOD, NCC and RIU in parallel. In order to compute such a similarity measure on the GPU, the way of computation is completely different compared to the same computation on the CPU. For instance, the similarity measure SSD in (11) is computed on the CPU by running over the compared images in a loop and adding the single differences to the whole sum. After computing this whole sum, it is divided by the number of pixels in the overlapping area of both images M. In contrast, on the GPU only the computation of the differences between two pixels is computed within a shader program. These computed differences are stored in the output texture as intermediate results. The following summation and division is efficiently executed by using mipmaps that compute the average of the output texture. The final values of the similarity measures are calculated from these reduced textures on the CPU. In Figure 3 an excerpt of the second fragment shader is shown. In an analogous manner, the third fragment shader calculates the intermediate results for the three intensity-based similarity measures GDI, GC, PI in parallel. 3 Results and Discussion In order to evaluate the performance and the precision of our algorithm, we use a Ge- Force 7800 GS AGP with 256 MB. The GPU programming is done entirely in OpenGL and Cg. The CPU source code is executed on a single Pentium 4 CPU with 3.2 GHz. In the first experiment, we evaluated the performance of our GPU algorithm and compared it to the CPU+GPU algorithm, in which the DRR generation was also executed on the GPU, but the computation of the similarity measures was executed on the CPU. The size of the X-ray images varied from 64 2 to pixels and the size of the CT volume varied from 64 3 to voxels. As we can see in Table 1, the GPU algorithm was at least three and at most six times faster than the CPU+GPU algorithm. The slower performance of the CPU+GPU

8 8 // read mean values from input textures... float4 vecmeanfll = float4(value0, value0, value0, value0); float4 vecmeandrr = float4(value1, value1, value1, value1); float4 vecmeanriu = float4(value2, value2, value2, value2); float4 vecmeanfllminusdrr = float4(value3, value3, value3, value3); // read fll value, drr value, and compute difference of them float4 fll = tex2d(texture0, coords); float4 drr = tex2d(texture1, coords); float4 DiffFLLMinusDRR = fll - drr; // compute intermediate results for SSD, SAD, RIU, VOD float4 resultssd = pow((difffllminusdrr), 2); float4 resultsad = abs(difffllminusdrr); float4 resultriu = pow((fll + BIAS) / (drr + BIAS) - vecmeanriu, 2); float4 resultvod = pow((difffllminusdrr) - vecmeanfllminusdrr, 2); // write on Output0 setoutput(output0, resultssd, resultsad, resultriu, resultvod); Figure 3. Excerpt of the second fragment shader that computes the simple intensity-based similarity measures that do not require spatial information. X-ray CT CPU+GPU GPU DRR AESM image volume algorithm algorithm GPU CPU GPU ms 792.0ms 757.7ms ms 34.3ms ms 235.6ms 216.2ms ms 19.4ms ms 88.6ms 72.7ms 256.2ms 15.9ms ms 16.3ms 11.4ms 63.2ms 4.9ms ms 8.4ms 3.7ms 20.2ms 4.7ms Table 1. Comparison of our GPU algorithm and the CPU+GPU algorithm, in which the DRR generation was also executed on the GPU, but the computation of the similarity measures was executed on the CPU. In both algorithms, eight similarity measures (i.e. AESM) were calculated. The parts of these algorithms are also listed separately. The measured times are averaged over 5000 iterations. algorithm is caused by the download of the textures from the GPU to the CPU. Additionally, on the CPU the similarity measures cannot be computed in parallel as on the GPU. They are computed one after the other. The advantages of the GPU algorithm are especially noticeable if large images are used. In Table 1 the measured times for both parts of our GPU algorithm are listed separately. One can easily realize that on the GPU the main part of the runtime is consumed for the DRR generation, whereas on the CPU the main part of the runtime is consumed for the computation of the eight similarity measures. It is shown in Table 2 that the minimal and maximal computation time for computing a single similarity measure varies much on the CPU, but not on the GPU. If we look at Table 1 and Table 2, there is no major difference on the GPU if one or eight similarity measures are computed. However, this does not hold for the CPU. In the second experiment, we evaluated the precision of our GPU algorithm. Additionally, we checked if the registration result could be improved if eight similarity measures were used in parallel instead of one single similarity measure. Therefore, the average of eight different similarity measures was used as a new combined similarity measure that was already described in section 2.2. For the experiment, we used two phantom models of a head and of a thorax. In this experiment the X-ray image of the head in Figure 1 was registered to the volume of the head and the X-ray image of the thorax in Figure 1 was registered to the volume of the thorax. The 2D/3D registration was solved by a combination of the global optimizer Adaptive Random Search [13] and the local optimizer Best Neighbor [14]. As the ground truth position is known for

9 X-ray image CT volume CPU GPU Min Max Min Max ms ms 23.1ms 23.5ms ms 545.1ms 8.1ms 8.2ms ms 131.2ms 4.4ms 4.5ms ms 31.7ms 3.3ms 3.4ms ms 8.2ms 3.3ms 3.4ms Table 2. The minimal and maximal time that was needed to compute a single similarity measure on the CPU and on the GPU. The measured times are averaged over 5000 iterations. precision AESM GC GDI NCC PI RIU SAD SSD VOD µ head 1.5mm 1.9mm 14.0mm 1.1mm 6.6mm 0.9mm 1.7mm 1.4mm 25.1mm σ head 1.4mm 1.8mm 10.5mm 0.8mm 8.5mm 0.6mm 1.4mm 1.1mm 16.7mm µ thorax 1.3mm 0.3mm 4.5mm 19.1mm 23.8mm 20.5mm 7.2mm 8.4mm 1.3mm σ thorax 0.8mm 0.1mm 8.6mm 9.9mm 12.7mm 10.7mm 3.6mm 4.3mm 0.8mm Table 3. The registration error (in mm) of our GPU algorithm is specified by its mean value µ and its deviation σ for both phantom models. The indicated similarity measure was used for the registration. The measured errors were averaged over 10 registration runs. both phantom models, the registration error can be measured in mm using the euclidean distance in the image. We can see in Table 3 that using our new similarity measure AESM (the Average of Eight Similarity Measures) the mean registration error was for both phantom models 1.5mm or smaller. In the experiment with the phantom model of the head only three single similarity measures (NCC, RIU and SSD) were (a little bit) better. However, the five other single similarity measures were worse than AESM. The similarity measures GDI and VOD were extremely bad and facilitated no correct registration if the phantom model of the head was used. In the experiment with the phantom model of the thorax only two similarity measures (GC and VOD) were (a little bit) better than AESM, whereas three similarity measures (GDI, SAD and SSD) were (a little bit) worse than AESM and three similarity measures (NCC, PI and RIU) were extremely bad. Depending on the used phantom model, a single similarity measure can either provide good or bad registration results. For instance, the similarity measure NCC provided good registration results for the head and bad registration results for the thorax. In contrast, the similarity measure VOD provided good registration results for the thorax and bad registration results for the head. Our newly created similarity measure provided constantly good registration results for both phantom models. As it was mentioned above, the computational costs do not differ much if one or eight similarity measures are computed on the GPU. Because of that, it is more reasonable to use the AESM which provides better registration results and does not produce significantly more costs. 9 4 Conclusions and Future Work In this paper we presented a method that performs the rigid 2D/3D image registration efficiently on the GPU. As one main contribution of this paper, we described an efficient method for generating realistic DRRs that are visually similar to X-ray images. Because of their similarity, costly post-processing algorithms are avoided and the image registration is simplified. In our method for generating realistic DRRs we modeled some of the electronic post-processes of current X-ray C-arm-systems. As another main contribution, the GPU was used to compute eight intensity-based similarity measures between the DRR and the X-ray image in parallel. A combination of these eight similarity measures was used as a new similarity measure for the optimization.

10 10 We evaluated the performance and the precision of our 2D/3D image registration algorithm using two phantom models. Compared to a CPU+GPU algorithm, our GPU algorithm was between three and six times faster. In contrast to single similarity measures, the new similarity measure AESM achieved precise and robust registration results for two phantom models. In the future we will extend our approach that is currently limited to intensity-based similarity measures to feature-based similarity measures. We will also improve our simple method for combining similarity measures so that good similarity measures are emphasized and bad similarity measures are suppressed. Literatur 1. Goecke, R., Weese, J., Schumann, H.: Fast volume rendering methods for voxel-based 2d/3d registration - a comparative study. In: Proceedings of International Workshop on Biomedical Image Registration 99. (1999) Khamene, A., Chisu, R., Wein, W., Navab, N., Sauer, F.: A Novel Projection Based Approach for Medical Image Registration. In: Third International Workshop on Biomedical Image Registration, Springer, Berlin (2006) Russakoff, D.B., Rohlfing, T., Mori, K., Rueckert, D., Adler, Jr., J.R., Maurer, Jr., C.R.: Fast Generation of Digitally Reconstructed Radiographs using Attenuation Fields with Application to 2D-3D Image Registration. IEEE Transactions on Medical Imaging 24(11) (2005) Strzodka, R., Droske, M., Rumpf, M.: Image Registration by a Regularized Gradient Flow - A Streaming Implementation in DX9 Graphics Hardware. Computing 73(4) (2004) Köhn, A., Drexl, J., Ritter, F., König, M., Peitgen, H.O.: GPU Accelerated Image Registration in Two and Three Dimensions. In: Bildverarbeitung für die Medizin 2006, Springer, Berlin (2006) Penney, G.P.: Registration of Tomographic Images to X-Ray Projections for Use in Image Guided Interventions. PhD thesis, King s College, London (1999) 7. LaRose, D.A.: Iterative X-Ray/CT Registration Using Accelerated Volume Rendering. PhD thesis, Carnegie Mellon University (2001) 8. Khamene, A.: Automatic Registration of Portal Images and Volumetric CT for Patient Positioning in Radiation Therapy. Medical Image Analysis 10 (2005) Wein, W.: Intensity Based Rigid 2D-3D Registration Algorithms for Radiation Therapy. Master s thesis, TU München (2003) 10. Krüger, J., Westermann, R.: Acceleration Techniques for GPU-based Volume Rendering. In: Proc. of the 14th IEEE Visualization 2003, Washington, DC, USA, IEEE Computer Society (2003) Scharsach, H.: Advanced GPU Raycasting. In: Proc. of Central European Seminar on Computer Graphics for students (2005) Trucco, E., Verri, A.: Introductory Techniques for 3 D Computer Vision. Prentice Hall, New York (1998) 13. Zhigljavsky, A.: Theory of Global Random Search. Kluwer Academic, Edmonton (1991) 14. Törn, A., Zilinskas, A.: Global Optimization. Springer, Berlin (1989) 15. Oppelt, A., ed.: Imaging Systems for Medical Diagnostics. Publicis, Erlangen (2005) 16. Cox, G.: Automatic Registration of Temporal Image Pairs for Digital Subtraction. In: Proc. of SPIE Medical Imaging 1994: Image Processing. Volume 2167., SPIE Press (1994) Woods, R.P., Cherry, S.R., Mazziotta, J.C.: Rapid Automated Algorithm for Alignment and Reslicing PET Images. Journal of Computer Assisted Tomography 16(4) (1992)

11 18. Penney, G.P., Weese, J., Little, J.A., Desmedt, P., Hill, D.L., Hawkes, D.J.: A Comparison of Similarity Measures for Use in 2-D-3-D Medical Image Registration. IEEE Transactions on Medical Imaging 17(4) (1998)