Hardware Acceleration for Vessel Visualization Tasks

Transcription

1 Hardware Acceleration for Vessel Visualization Tasks 1

2 Research Context Research projects on vessel visualization with Vis-Group of the Otto von Guericke University of Magdeburg Automatic Transfer Functions for Visual Emphasis of Coronary Artery Plaque S. Glaßer, S. Oeltze, A. Hennemuth, C. Kubisch, A. Mahnken, S. Wilhelmsen, and B. Preim [Computer Graphics Forum, 2010] Vessel Visualization with Volume Rendering C.Kubisch, S. Glaßer, M. Neugebauer and B. Preim [Visualization in Medicine and Life Sciences II] 2

3 Volume Visualization Standard greyscale display techniques Advanced display, aiding exploration [dataset courtesy, Dr. S. Achenbach University Erlangen- Nürnberg] 3

4 Medical Background Cerebral aneurysm Incidence ~6% western population Weakened vessel wall Higher risk of rupture Infarct (fatality ~67%) Blood flow has main impact Inclusion into decision making process 4

5 Medical Background Coronary Artery Disease (CAD) Result of accumulations in the coronary artery wall Soft Plaques Fibrous Plaques Hard Plaques Progressive CAD leads to stenoses Aorta RCA normal Illustration of the heart and coronary arteries positive remodeling LCA LCX LAD negative remodeling Cross-sections of vessel walls 5

6 Medical Background Computer Tomography Angiography (CTA) Asymptomatic patients Abnormal coronary spatial variation Contrast agent (varying Hounsfield Units HU) Multiplanar reformation (MPR) Curved planar reformation (CPR) DVR view 6

7 Volume Rendering Pipeline Data Acqusition CT / MRI Scanners Pre-processing of RAW data Segmentation / Filtering Extracting structures, organs, vessels... Display 2D and 3D Views, GPU Raycasting Transfer function (TF) for coloring and opacity mapping 1. Contrast enhanced CTA dataset 2. Segmentated coronary arteries 3. Skeleton of binary segmentation result 7

8 Upsampling Anisotropic Medical Data Often higher in-plane resolution Visible interpolation issues Higher Order Runtime Filtering Can interfer with sampling performance Upsample along slice direction Inject additional slices Higher order Interpolation Before After 8

9 Upsampling During load/post-load Kernel launched to interpolate slices 1D convolution Lanczos 3/5 Filter Update texture cudamemcpy3d Constant memory convolution weight table surface writes gltexsubimage from PBO Thread computes inbetween voxels at once Kernel launch per interpolation step allows streamed loading 9

10 Automatic Transfer Function Algorithm by S.Glaßer et al. ported to CUDA Adapted TFs are derived from stochastic analysis μ blood, σ blood and μ wall, σ wall to account for contrast agent 2D and 3D display version to show vessel wall and potential plaques [S. Glaßer et al. 2010] TF 3D TF 2D 10

11 Automatic Transfer Function CPR view of datasets [dataset courtesy, Dr. S. Achenbach University Erlangen- Nürnberg] DVR view of two datasets MPR view of datasets (arrows hint possible fibrous / soft plagues) [S. Glaßer et al. 2010] 11

12 Blood Estimation Approximation of μ blood, σ blood Segmentation result primarily contains blood voxels Fitting of normal distribution by iterative reduction of cost function Logarithmic scaled histogram of segmentation result with fitted normal distribution (blue curve) 12

13 Blood Estimation Histogram Kernels Run through entire volume and use segmentation mask Warp level histograms using shared memory atomics Warp level histograms combined to block level Block level histograms combined through extra kernel Block Histograms in Global Memory syncthreads(); Warp Histograms in Shared Memory MergeKernels<<<blocks,...>>>(...); 13

14 Blood Estimation Normal Distribution Fitting Kernel Spawn multiple blocks around histogramm peak Each block tries to optimize finding standard deviation for its mean value 14

15 Blood Estimation Threads compute cost function Difference between histogram and probability function Reduction in shared memory Control thread steers fitting of standard deviation for (...){ syncthreads(); // receive sigma from shared memory sigma = s_sigma; syncthreads(); // compute differences to normal // distribution // thread level reduction syncthreads(); } if (tid == 0){ // update sigma based on error sum s_sigma =.. } 15

16 Vessel Wall Estimation Local Histogram Analysis Favor long, non-branching vessels Sample cross-sections Create profile images per point If likely a wall, samples contribute to vessel histogram Derive mean and standard deviation 16

17 Vessel Wall Estimation Local Histogram Kernel Every cross section is one warp Each thread block works on a couple of points CTA spawns as many blocks as required for path Vessel path divided into blocks Warp index is distance from center 17

18 Vessel Wall Estimation Global Memory for profile images (one per warp) Kernel Steps: Sample rays into profile image Blur & Edge Filter in profile image Compute column threshold based on gradient SyncThreads Feed samples into shared memory histogram Based on threshold / edge SyncThreads Move shared to block level histogram Look for vertical structures (likely vessel wall) Contribute intensity to histogram 18

19 Vessel Branch Specific TF Segmentation mask also stores tags Allow local transfer function during rendering the volume CUDA Dilation Kernel for branch tags Each dilation cycle runs through active slices Slice is active if itself or neighboring slice was changed in last cycle Changes are communicated with help of syncthreads_or(change); 19

20 3D View Rendering GPU Raycasting OpenGL rasterizes coarse mesh for ray start/end positions Single pass: use GL_MIN/MAX blending and output depth & 1- depth Two pass: just reverse gldepthfunc and output pos Do volume integration between positions encoded in FBO textures 20

21 3D View Rendering Pre-Integrated Rendering 2D Lookup table preintegrates transition between different intensity levels Generate via CUDA or GL Reduce 3d sampling rate MRT and Post Processing Example use of SSAO or Stippling of obstructed parts 21

22 2D View Rendering MPR and CPR Views (A. Kanitsar et al.) Projected mesh along the vessel path Mesh Vertices encode 3D volume positions but are 2D on screen Isometric Extrusion Sample along normal with attenuated colors Stretched Planar Reformation Curved Planar Reformation 22

23 Vessel Path Smoothing OpenGL Implementation Transform feedback to update vessel vertices Allows fast and easy linear buffer updates Draw GL_POINTS (1D Kernel) Ping Pong Buffers Vertex Shader Centerline Correction (A. Kanitsar) Cross section volume ray casting Smoothing of the path Bind VertexBuffer also as TextureBuffer Use gl_vertexid to access neighboring vertices Swap read/write buffers VBO for self TBO for neighbors VBO/TBO XBO in vec4 pos; XBO VBO/TBO texelfetch(... gl_vertexid +/- 1); 23

24 Related Topic Vessel-Ness Filter Avoids segmentation Compute Hessian (A. F. Frangi et al.) Look for cylindrical shapes Compute Polar Profile per voxel (A. Joshi et al.) Analyze for round shapes Algorithm looks very GPU-port friendly, Parallel and lots of texture sampling 24

25 Thank You cudasynchronize( talk ); Contact: Christoph Kubisch 25

26 References Automatic Transfer Functions for Visual Emphasis of Coronary Artery Plaque S. Glaßer, S. Oeltze, A. Hennemuth, C. Kubisch, A. Mahnken, S. Wilhelmsen, and B. Preim [EuroGraphics, Computer graphics forum 29 (2010), No.1, pp ] Vessel Visualization with Volume Rendering C.Kubisch, S. Glaßer, M. Neugebauer and B. Preim [Visualization in Medicine and Life Sciences II, ; Springer-Verlag] CPR: curved planar reformation Kanitsar A, Fleischmann D, Wegenkittl R, Felkel P, Gröller ME.. [IEEE Visualization; p ] Multiscale Vessel Enhancement Filtering Frangi AF, Frangi RF, Niessen WJ, Vincken KL, Viergever MA [Computer (1998) Volume: 1496, Issue: 3, ; Springer-Verlag] Effective visualization of complex vascular structures using a non-parametric vessel detection method Joshi A, Qian X, Dione D, Bulsara K, Breuer C, Sinusas A, et al. [IEEE Visualization; 2008; 14(6): ] 26

27 Blood Estimation Histogram Kernels Run through entire volume and test against segmentation Warp level histograms using shared memory atomics Limit histogram computation for a sub-range of intensity values Saves histogram bins and therefore shared memory Warp level histograms combined to block level Block level histograms combined through extra kernel //Per-warp subhistogram storage shared uint s_hist[]; uint *s_warphist= s_hist + (threadidx.x >> WARP_BITS) * HISTOBINS;... // iterate through coordinates uint id = tex3d( l_texid, coord.x,coord.y,coord.z); if (id && c_histogramids[id]){ float val = tex3d( l_texvalue, coord.x,coord.y,coord.z); if (val > fromhu && val < tohu){ float rand = HybridTaus(z1,z2,z3,z4); uint data = float2uint_rd(((val - fromhu)*divhu) + rand); data = min(histobins,data); atomicadd(s_warphist + data, 1); } }.. //Merge per-warp histograms into per-block syncthreads(); for(uint bin = threadidx.x; bin < HISTOBINS; bin += blockdim.x) { uint sum = 0; } for(uint i = 0; i < WARP_COUNT; i++){ sum += s_hist[bin + i * HISTOBINS]; } d_partialhistograms[blockidx.x * HISTOBINS + bin] = sum; 27

28 Blood Estimation Threads compute cost function Difference between histogram and probability function Reduction in shared memory Control thread steers fitting of standard deviation for (uint s = 0; s < NORMALDIST_STEPS; s++){ syncthreads(); // receive broadcast float sigma = s_errors[normaldist_s_sigma]; syncthreads(); // scale factor float ndist = getnormaldist(peakbin,mean,sigma); float scale = peakvalue/ndist; // compute difference float errorsum = 0.0f; for(uint i = tid; i < HISTOBINS; i+= BLOCKTHREADS){ float errorf = fabs(d_histogram[i] - (scale*getnormaldist((float)i,mean,sigma))); errorf *= intervalcheck((float)i,mean,sigma); errorsum += errorf; } s_errors[tid] = errorsum; } // thread level reduction blocksum<float>(s_errors,tid,blocksize); if (tid == 0){ // update sigma based error sum s_errors[normaldist_s_sigma] =.. } 28

29 Vessel Branch Specific TF Thread Stride CUDA Dilation Kernel No übertuned solution needed, dilation done only once Worker threads to saturate hardware Threads work on columns with stride Blocks work on rows with stride Global memory Two slices Blocklevel had change buffer For each run, iterate active slices Output into active slice (alternate between two) If change within slice, include self and neighbor slices in working set for next iteration Write-back output of previous slice (not current, to keep uniform growth) uint change = 0; // each block works on a single line for ( int y = blockidx.x; y < h; y+= griddim.x){ // all threads work within line uchar *prow = ((pwriteslice)+y*pitch); for ( int x = threadid; x < w; x += threadstride ){ prow[x] = Dilate(x,y,z,clearid,change); } } change = syncthreads_or(change); if (threadidx.x == 0){ // first thread within block writes result // to global grid mem } Block Stride Active Threads pgridmem[blockidx.x] = change; 29

30 Vessel Path Smoothing CUDA Implementation Typical short vessel paths (< 1000 points) Can use a single saturated block, avoids ping-pong buffer Kernel Compute correction and write to global memory SyncThreads Read coordinates of neighbors Compute smooth value in register SyncThreads Write smooth to global SyncThreads 30