book

GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation

Name: GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation
ISBN: 9780321545411

by Matt Pharr, Randima Fernando

March 2005

Intermediate to advanced

880 pages

18h 59m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
Intended AudienceTrying the ExamplesAcknowledgments
Contributors
I. Geometric Complexity
1. Toward Photorealism in Virtual Botany
1.1. Scene Management1.1.1. The Planting Grid1.1.2. Planting Strategy1.1.3. Real-Time Optimization1.2. The Grass Layer1.2.1. Simulating Alpha Transparency via Dissolve1.2.2. Variation1.2.3. Lighting1.2.4. Wind1.3. The Ground Clutter Layer1.4. The Tree and Shrub Layers1.5. Shadowing1.6. Post-Processing1.6.1. Sky Dome Blooming1.6.2. Full-Scene Glow1.7. Conclusion1.8. References
2. Terrain Rendering Using GPU-Based Geometry Clipmaps
2.1. Review of Geometry Clipmaps2.2. Overview of GPU Implementation2.2.1. Data Structures2.2.2. Clipmap Size2.3. Rendering2.3.1. Active Levels2.3.2. Vertex and Index Buffers2.3.3. View Frustum Culling2.3.4. DrawPrimitive Calls2.3.5. The Vertex Shader2.3.6. The Pixel Shader2.4. Update2.4.1. Upsampling2.4.2. Residuals2.4.3. Normal Map2.5. Results and Discussion2.6. Summary and Improvements2.6.1. Vertex Textures2.6.2. Eliminating Normal Maps2.6.3. Memory-Free Terrain Synthesis2.7. References
3. Inside Geometry Instancing
3.1. Why Geometry Instancing?3.2. Definitions3.2.1. Geometry Packet3.2.2. Instance Attributes3.2.3. Geometry Instance3.2.4. Render and Texture Context3.2.5. Geometry Batch3.3. Implementation3.3.1. Static Batching3.3.2. Dynamic Batching3.3.3. Vertex Constants Instancing3.3.4. Batching with the Geometry Instancing API3.4. Conclusion3.5. References

4. Segment Buffering
4.1. The Problem Space4.2. The Solution4.3. The Method4.3.1. Segment Buffering, Step 14.3.2. Segment Buffering, Step 24.3.3. Segment Buffering, Step 34.4. Improving the Technique4.5. Conclusion4.6. References
5. Optimizing Resource Management with Multistreaming
5.1. Overview5.2. Implementation5.2.1. Multistreaming with DirectX 9.05.2.2. Resource ManagementThe Mesh Resource5.2.3. Processing VerticesGeometry DataTexture DataAnimation DataIndex DataRendering the Streams5.3. Conclusion5.4. References
6. Hardware Occlusion Queries Made Useful
6.1. Introduction6.2. For Which Scenes Are Occlusion Queries Effective?6.3. What Is Occlusion Culling?6.4. Hierarchical Stop-and-Wait Method6.4.1. The Naive Algorithm, or Why Use Hierarchies at All?6.4.2. Hierarchies to the Rescue!6.4.3. Hierarchical Algorithm6.4.4. Problem 1: Stalls6.4.5. Problem 2: Query Overhead6.5. Coherent Hierarchical Culling6.5.1. Idea 1: Being Smart and Guessing6.5.2. Idea 2: Pull Up, Pull Up6.5.3. Algorithm6.5.4. Implementation Details6.5.5. Why Are There Fewer Stalls?6.5.6. Why Are There Fewer Queries?6.5.7. How to Traverse the Hierarchy6.6. Optimizations6.6.1. Querying with Actual Geometry6.6.2. Z-Only Rendering Pass6.6.3. Approximate Visibility6.6.4. Conservative Visibility Testing6.7. Conclusion6.8. References
7. Adaptive Tessellation of Subdivision Surfaces with Displacement Mapping
7.1. Subdivision Surfaces7.1.1. Some Definitions7.1.2. Catmull-Clark Subdivision7.1.3. Using Subdivision for TessellationAdaptive Subdivision7.1.4. Patching the Surface7.1.5. The GPU Tessellation AlgorithmCPU ProcessingCreating the PatchesThe Flatness TestSubdivisionLimit Positions and Normals7.1.6. Watertight Tessellation7.2. Displacement Mapping7.2.1. Changing the Flatness Test7.2.2. Shading Using Normal Mapping7.3. Conclusion7.4. References
8. Per-Pixel Displacement Mapping with Distance Functions
8.1. Introduction8.2. Previous Work8.3. The Distance-Mapping Algorithm8.3.1. Arbitrary Meshes8.4. Computing the Distance Map8.5. The Shaders8.5.1. The Vertex Shader8.5.2. The Fragment Shader8.5.3. A Note on Filtering8.6. Results8.7. Conclusion8.8. References
II. Shading, Lighting, and Shadows
9. Deferred Shading in S.T.A.L.K.E.R.
9.1. Introduction9.2. The Myths9.3. Optimizations9.3.1. What to Optimize9.3.2. Lighting OptimizationsOptimizing the Sun9.3.3. G-Buffer-Creation Optimizations9.3.4. Shadowing OptimizationsEfficient Omni Lights9.4. Improving Quality9.4.1. The Power of “Virtual Position”9.4.2. Ambient Occlusion9.4.3. Materials and Surface-Light Interaction9.5. Antialiasing9.5.1. Efficient Tone Mapping9.5.2. Dealing with Transparency9.6. Things We Tried but Did Not Include in the Final Code9.6.1. Elevation Maps9.6.2. Real-Time Global Illumination9.7. Conclusion9.8. References
10. Real-Time Computation of Dynamic Irradiance Environment Maps
10.1. Irradiance Environment Maps10.2. Spherical Harmonic Convolution10.3. Mapping to the GPU10.3.1. Spatial to Frequency Domain10.3.2. Convolution and Back Again10.4. Further Work10.5. Conclusion10.6. References
11. Approximate Bidirectional Texture Functions
11.1. Introduction11.2. Acquisition11.2.1. Setup and Acquisition11.2.2. Assembling the Shading Map11.3. Rendering11.3.1. Detailed Algorithm11.3.2. Real-Time Rendering11.4. Results11.4.1. Discussion11.5. Conclusion11.6. References
12. Tile-Based Texture Mapping
12.1. Our Approach12.2. Texture Tile Construction12.3. Texture Tile Packing12.4. Texture Tile Mapping12.5. Mipmap Issues12.6. Conclusion12.7. References
13. Implementing the mental images Phenomena Renderer on the GPU
13.1. Introduction13.2. Shaders and Phenomena13.3. Implementing Phenomena Using Cg13.3.1. The Cg Vertex Program and the Varying Parameters13.3.2. The main() Entry Point for Fragment Shaders13.3.3. The General Shader Interfaces13.3.4. Example of a Simple Shader13.3.5. Global State Variables13.3.6. Light Shaders13.3.7. Texture Shaders13.3.8. Bump Mapping13.3.9. Environment and Volume Shaders13.3.10. Shaders Returning Structures13.3.11. Rendering Hair13.3.12. Putting It All Together13.4. Conclusion13.5. References
14. Dynamic Ambient Occlusion and Indirect Lighting
14.1. Surface Elements14.2. Ambient Occlusion14.2.1. The Multipass Shadowing Algorithm14.2.2. Improving Performance14.3. Indirect Lighting and Area Lights14.4. Conclusion14.5. References
15. Blueprint Rendering and “Sketchy Drawings”
15.1. Basic Principles15.1.1. Intermediate Rendering Results15.1.2. Edge Enhancement15.1.3. Depth Sprite Rendering15.2. Blueprint Rendering15.2.1. Depth PeelingPerforming Two Depth Tests15.2.2. Extracting Visible and Nonvisible Edges15.2.3. Composing Blueprints15.2.4. Depth Masking15.2.5. Visualizing Architecture Using Blueprint Rendering15.3. Sketchy Rendering15.3.1. Edges and Color Patches15.3.2. Applying Uncertainty15.3.3. Adjusting Depth15.3.4. Variations of Sketchy RenderingRoughened Profiles and Color TransitionsRepeated Edges15.3.5. Controlling UncertaintyPreserving Geometric PropertiesEnlarging the Geometry15.3.6. Reducing the Shower-Door Effect15.4. Conclusion15.5. References
16. Accurate Atmospheric Scattering
16.1. Introduction16.2. Solving the Scattering Equations16.2.1. Rayleigh Scattering vs. Mie Scattering16.2.2. The Phase Function16.2.3. The Out-Scattering Equation16.2.4. The In-Scattering Equation16.2.5. The Surface-Scattering Equation16.3. Making It Real-Time16.4. Squeezing It into a Shader16.4.1. Eliminating One Dimension16.4.2. Eliminating the Other Dimension16.5. Implementing the Scattering Shaders16.5.1. The Vertex Shader16.5.2. The Fragment Shader16.6. Adding High-Dynamic-Range Rendering16.7. Conclusion16.8. References
17. Efficient Soft-Edged Shadows Using Pixel Shader Branching
17.1. Current Shadowing Techniques17.2. Soft Shadows with a Single Shadow Map17.2.1. Blurring Hard-Edged Shadows17.2.2. Improving EfficiencyBranching Like a TreePredict and Forecast17.2.3. Implementation DetailsPerformance Notes17.3. Conclusion17.4. References
18. Using Vertex Texture Displacement for Realistic Water Rendering
18.1. Water Models18.2. Implementation18.2.1. Water Surface Model18.2.2. Implementation Details18.2.3. Sampling Height Maps18.2.4. Quality Improvements and OptimizationsPacking Heights for Bilinear FilteringAvoiding Unnecessary Work with BranchingUsing Render-to-TextureBack Sides of Waves18.2.5. Rendering Local PerturbationsAnalytical Deformation ModelDynamic Displacement MappingFoam Generation18.3. Conclusion18.4. References
19. Generic Refraction Simulation
19.1. Basic Technique19.2. Refraction Mask19.3. Examples19.3.1. Water Simulation19.3.2. Glass Simulation19.4. Conclusion19.5. References
III. High-Quality Rendering
20. Fast Third-Order Texture Filtering
20.1. Higher-Order Filtering20.2. Fast Recursive Cubic Convolution20.3. Mipmapping20.4. Derivative Reconstruction20.5. Conclusion20.6. References
21. High-Quality Antialiased Rasterization
21.1. Overview21.2. Downsampling21.2.1. Comparison to Existing Hardware and Software21.2.2. Downsampling on the GPU21.3. Padding21.4. Filter Details21.5. Two-Pass Separable Filtering21.6. Tiling and Accumulation21.7. The Code21.7.1. The Rendering Loop21.7.2. The Downsample Class21.7.3. Implementation Details21.8. Conclusion21.9. References
22. Fast Prefiltered Lines
22.1. Why Sharp Lines Look Bad22.2. Bandlimiting the Signal22.2.1. Prefiltering22.3. The Preprocess22.4. Runtime22.4.1. Line Setup (CPU)22.4.2. Table Lookups (GPU)22.5. Implementation Issues22.5.1. Drawing Fat Lines22.5.2. Compositing Multiple Lines22.6. Examples22.7. Conclusion22.8. References
23. Hair Animation and Rendering in the Nalu Demo
23.1. Hair Geometry23.1.1. Layout and Growth23.1.2. Controlling the Hair23.1.3. Data Flow23.1.4. Tessellation23.1.5. Interpolation23.2. Dynamics and Collisions23.2.1. Constraints23.2.2. Collisions23.2.3. Fins23.3. Hair Shading23.3.1. A Real-Time Reflectance Model for HairThe Marschner Reflectance ModelSolid Geometry23.3.2. Real-Time Volumetric Shadows in HairOpacity Shadow MapsAn Updated ImplementationPerforming a Lookup23.4. Conclusion and Future Work23.5. References
24. Using Lookup Tables to Accelerate Color Transformations
24.1. Lookup Table Basics24.1.1. One-Dimensional LUTsLimitations of 1D LUTs24.1.2. Three-Dimensional LUTsLimitations of 3D LUTs24.1.3. Interpolation24.2. Implementation24.2.1. Strategy for Mapping LUTs to the GPU24.2.2. Cg ShaderShader AnalysisShader Optimization24.2.3. System Integration24.2.4. Extending 3D LUTs for Use with High-Dynamic-Range ImageryClampingNonuniformly Sampled Lattices24.3. Conclusion24.4. References
25. GPU Image Processing in Apple’s Motion
25.1. Design25.1.1. Loves and LoathingsImage In, Image OutImage In, Statistics OutColor TransformationsIndependent Neighborhood OperationsSequential Neighborhood OperationsConditional Execution25.1.2. Pick a LanguageARB_fragment_program25.1.3. CPU Fallback25.2. Implementation25.2.1. GPU Resource Limits25.2.2. Division by Zero25.2.3. Loss of Vertex Components25.2.4. Bilinear FilteringSofteningAlpha Fringes25.2.5. High-Precision Storage25.3. Debugging25.4. Conclusion25.5. References
26. Implementing Improved Perlin Noise
26.1. Random but Smooth26.2. Storage vs. Computation26.3. Implementation Details26.3.1. Optimization26.4. Conclusion26.5. References
27. Advanced High-Quality Filtering
27.1. Implementing Filters on GPUs27.1.1. Accessing Image Samples27.1.2. Convolution FiltersUsing 1D Textures for Rotationally Invariant KernelsApplying Very Large Kernels27.2. The Problem of Digital Image Resampling27.2.1. Background27.2.2. AntialiasingQuasi-Optimal Antialiasing27.2.3. Image ReconstructionImplementation27.3. Shock Filtering: A Method for Deblurring Images27.4. Filter Implementation Tips27.5. Advanced Applications27.5.1. Time Warping27.5.2. Motion Blur Removal27.5.3. Adaptive Texture Filtering27.6. Conclusion27.7. References
28. Mipmap-Level Measurement
28.1. Which Mipmap Level Is Visible?28.2. GPU to the Rescue28.2.1. Counting PixelsIs the First Mip Level Visible?Extending to Multiple Mipmap LevelsInterpreting the ResultsUsing the Results28.2.2. Practical Considerations in an EngineEmitting Modified Draw CallsAmortizing the OverheadsRGB Calibration Data28.2.3. ExtensionsMagnification and Juggling Powers of TwoMip-Level VelocityDerivative Instructions28.3. Sample Results28.4. Conclusion28.5. References
IV. General-Purpose Computation on GPUS: A Primer
29. Streaming Architectures and Technology Trends
29.1. Technology Trends29.1.1. Core Technology Trends29.1.2. ConsequencesCompute vs. CommunicateLatency vs. BandwidthPower29.2. Keys to High-Performance Computing29.2.1. Methods for Efficient Computation29.2.2. Methods for Efficient Communication29.2.3. Contrast to CPUs29.3. Stream Computation29.3.1. The Stream Programming ModelEfficient ComputationEfficient Communication29.3.2. Building a Stream Processor29.4. The Future and Challenges29.4.1. Challenge: Technology Trends29.4.2. Challenge: Power Management29.4.3. Challenge: Supporting More Programmability and Functionality29.4.4. Challenge: GPU Functionality Subsumed by CPU (or Vice Versa)?29.5. References
30. The GeForce 6 Series GPU Architecture
30.1. How the GPU Fits into the Overall Computer System30.2. Overall System Architecture30.2.1. Functional Block Diagram for Graphics Operations30.2.2. Functional Block Diagram for Non-Graphics Operations30.3. GPU Features30.3.1. Fixed-Function FeaturesGeometry InstancingEarly Culling/ClippingRasterizationZ-CullOcclusion QueryTexturingShadow Buffer SupportHigh-Dynamic-Range Blending Using fp16 Surfaces, Texture Filtering, and Blending30.3.2. Shader Model 3.0 Programming ModelVertex ProcessorFragment ProcessorFragment Processor Performance30.3.3. Supported Data Storage Formats30.4. Performance30.5. Achieving Optimal Performance30.5.1. Use Z-Culling Aggressively30.5.2. Exploit Texture Math When Loading Data30.5.3. Use Branching in Fragment Programs Judiciously30.5.4. Use fp16 Intermediate Values Wherever Possible30.6. Conclusion
31. Mapping Computational Concepts to GPUs
31.1. The Importance of Data Parallelism31.1.1. What Kinds of Computation Map Well to GPUs?Arithmetic Intensity31.1.2. Example: Simulation on a Grid31.1.3. Stream Communication: Gather vs. Scatter31.2. An Inventory of GPU Computational Resources31.2.1. Programmable Parallel ProcessorsVertex ProcessorsFragment ProcessorsRasterizerTexture UnitRender-to-TextureData Types31.3. CPU-GPU Analogies31.3.1. Streams: GPU Textures = CPU Arrays31.3.2. Kernels: GPU Fragment Programs = CPU “Inner Loops”31.3.3. Render-to-Texture = Feedback31.3.4. Geometry Rasterization = Computation Invocation31.3.5. Texture Coordinates = Computational Domain31.3.6. Vertex Coordinates = Computational Range31.3.7. Reductions31.4. From Analogies to Implementation31.4.1. Putting It All Together: A Basic GPGPU FrameworkInitializing and Finalizing a GPGPU ApplicationSpecifying KernelsStream ManagementSpecifying Computational Domain and RangeSpecifying Constant ParametersInvoking a KernelGetting Data Back to the CPUParallel Reductions31.5. A Simple Example31.6. Conclusion31.7. References
32. Taking the Plunge into GPU Computing
32.1. Choosing a Fast Algorithm32.1.1. Locality, Locality, Locality32.1.2. Letting Computation Rule32.1.3. Considering Download and Readback32.2. Understanding Floating Point32.2.1. Address Calculation32.3. Implementing Scatter32.3.1. Converting to Gather32.3.2. Address Sorting32.3.3. Rendering Points32.4. Conclusion32.5. References
33. Implementing Efficient Parallel Data Structures on GPUs
33.1. Programming with Streams33.2. The GPU Memory Model33.2.1. Memory Hierarchy33.2.2. GPU Stream TypesVertex StreamsFragment StreamsFrame-Buffer StreamsTexture Streams33.2.3. GPU Kernel Memory Access33.3. GPU-Based Data Structures33.3.1. Multidimensional Arrays1D Arrays2D Arrays3D ArraysHigher-Dimensional Arrays33.3.2. Structures33.3.3. Sparse Data StructuresStatic Sparse StructuresDynamic Sparse Structures33.4. Performance Considerations33.4.1. Dependent Texture Reads33.4.2. Computational Frequency and Program Specialization33.4.3. Pbuffer Survival Guide33.5. Conclusion33.6. References
34. GPU Flow-Control Idioms
34.1. Flow-Control Challenges34.2. Basic Flow-Control Strategies34.2.1. Predication34.2.2. Moving Branching up the PipelineStatic Branch ResolutionPrecomputation34.2.3. Z-Cull34.2.4. Branching Instructions34.2.5. Choosing a Branching Mechanism34.3. Data-Dependent Looping with Occlusion Queries34.4. Conclusion
35. GPU Program Optimization
35.1. Data-Parallel Computing35.1.1. Instruction-Level Parallelism35.1.2. Data-Level Parallelism35.2. Computational Frequency35.2.1. Precomputation of Loop Invariants35.2.2. Precomputation Using Lookup Tables35.2.3. Avoid Inner-Loop Branching35.2.4. The Swizzle Operator35.3. Profiling and Load Balancing35.4. Conclusion35.5. References
36. Stream Reduction Operations for GPGPU Applications
36.1. Filtering Through Compaction36.1.1. Running Sum Scan36.1.2. Scatter Through Search/GatherOptimization36.1.3. Filtering Performance36.2. Motivation: Collision DetectionPorting Collision Detection to the GPU36.3. Filtering for Subdivision Surfaces36.3.1. Subdivision on Streaming ArchitecturesDetails Specific to Streaming on the GPU36.4. Conclusion36.5. References
V. Image-Oriented Computing
37. Octree Textures on the GPU
37.1. A GPU-Accelerated Hierarchical Structure: The N3-Tree37.1.1. Definition37.1.2. ImplementationStorageAccessing the Structure: Tree LookupFurther OptimizationsEncoding Indices37.2. Application 1: Painting on Meshes37.2.1. Creating the Octree37.2.2. Painting37.2.3. RenderingLinear InterpolationMipmapping37.2.4. Converting the Octree Texture to a Standard 2D Texture37.3. Application 2: Surface Simulation37.4. Conclusion37.5. References
38. High-Quality Global Illumination Rendering Using Rasterization
38.1. Global Illumination via Rasterization38.2. Overview of Final Gathering38.2.1. Two-Pass Methods38.2.2. Final Gathering38.2.3. Problems with Two-Pass Methods38.3. Final Gathering via Rasterization38.3.1. Clustering of Final Gathering Rays38.3.2. Ray Casting as Multiple Parallel Projection38.4. Implementation Details38.4.1. Initialization38.4.2. Depth Peeling38.4.3. Sampling38.4.4. Performance38.5. A Global Illumination Renderer on the GPU38.5.1. The First Pass38.5.2. Generating Visible Points Data38.5.3. The Second Pass38.5.4. Additional SolutionsAliasingFlickering and Popping38.6. Conclusion38.7. References
39. Global Illumination Using Progressive Refinement Radiosity
39.1. Radiosity Foundations39.1.1. Progressive Refinement39.2. GPU Implementation39.2.1. Visibility Using Hemispherical Projection39.2.2. Form Factor Computation39.2.3. Choosing the Next Shooter39.3. Adaptive Subdivision39.3.1. Texture Quadtree39.3.2. Quadtree Subdivision39.4. Performance39.5. Conclusion39.6. References
40. Computer Vision on the GPU
40.1. Introduction40.2. Implementation Framework40.3. Application Examples40.3.1. Using Sequences of Fragment Programs for Computer VisionCorrecting Radial DistortionA Canny Edge Detector40.3.2. Summation OperationsTracking Hands40.3.3. Systems of Equations for Creating Image PanoramasVideoOrbits40.3.4. Feature Vector Computations40.4. Parallel Computer Vision Processing40.5. Conclusion40.6. References
41. Deferred Filtering: Rendering from Difficult Data Formats
41.1. Introduction41.2. Why Defer?41.3. Deferred Filtering Algorithm41.4. Why It Works41.5. Conclusions: When to Defer41.6. References
42. Conservative Rasterization
42.1. Problem Definition42.2. Two Conservative Algorithms42.2.1. Clip Space42.2.2. The First AlgorithmImplementation42.2.3. The Second AlgorithmImplementationUnderestimated Conservative Rasterization42.3. Robustness Issues42.4. Conservative Depth42.5. Results and Conclusions42.6. References
VI. Simulation and Numerical Algorithms
43. GPU Computing for Protein Structure Prediction
43.1. Introduction43.2. The Floyd-Warshall Algorithm and Distance-Bound Smoothing43.3. GPU Implementation43.3.1. Dynamic Updates43.3.2. Indexing Data Textures43.3.3. The Triangle Approach43.3.4. Vectorization43.4. Experimental Results43.5. Conclusion and Further Work43.6. References
44. A GPU Framework for Solving Systems of Linear Equations
44.1. Overview44.2. Representation44.2.1. The “Single Float” Representation44.2.2. Vectors44.2.3. MatricesFull MatricesBanded Sparse MatricesRandom Sparse Matrices44.3. Operations44.3.1. Vector Arithmetic44.3.2. Vector Reduce44.3.3. Matrix-Vector ProductFull and Banded Sparse Matrix-Vector ProductRandom Sparse Matrix-Vector Product44.3.4. Putting It All Together44.3.5. Conjugate Gradient Solver44.4. A Sample Partial Differential Equation44.4.1. The Crank-Nicholson Scheme44.5. Conclusion44.6. References
45. Options Pricing on the GPU
45.1. What Are Options?45.2. The Black-Scholes Model45.3. Lattice Models45.3.1. The Binomial Model45.3.2. Pricing European Options45.4. Conclusion45.5. References
46. Improved GPU Sorting
46.1. Sorting Algorithms46.2. A Simple First Approach46.3. Fast Sorting46.3.1. Implementing Odd-Even Merge Sort46.4. Using All GPU Resources46.4.1. Implementing Bitonic Merge Sort46.5. Conclusion46.6. References
47. Flow Simulation with Complex Boundaries
47.1. Introduction47.2. The Lattice Boltzmann Method47.3. GPU-Based LBM47.3.1. Algorithm Overview47.3.2. Packing47.3.3. Streaming47.4. GPU-Based Boundary Handling47.4.1. GPU-Based Voxelization47.4.2. Periodic Boundaries47.4.3. Outflow Boundaries47.4.4. Obstacle Boundaries47.5. Visualization47.6. Experimental Results47.7. Conclusion47.8. References
48. Medical Image Reconstruction with the FFT
48.1. Background48.2. The Fourier Transform48.3. The FFT Algorithm48.4. Implementation on the GPU48.4.1. Approach 1: Mostly Loading the Fragment Processor48.4.2. Approach 2: Loading the Vertex Processor, the Rasterizer, and the Fragment Processor48.4.3. Load Balancing48.4.4. Benchmarking Results48.5. The FFT in Medical Imaging48.5.1. Magnetic Resonance Imaging48.5.2. Results in MRIExample 1: Mouse HeartExample 2: Human Head48.5.3. Ultrasonic ImagingResults in Ultrasonic Imaging48.6. Conclusion48.7. References
Inside Front Cover
Inside Back Cover

Content preview from GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation

Chapter 26. Implementing Improved Perlin Noise

Simon GreenNVIDIA Corporation

This chapter follows up on Ken Perlin’s chapter in GPU Gems, “Implementing Improved Perlin Noise” (Perlin 2004). Whereas Ken’s chapter discussed how to implement fast approximations to procedural noise using 3D textures, here we describe a working GPU implementation of the improved noise algorithm in both Microsoft Direct 3D Effects (FX) and CgFX syntax that exactly matches the reference CPU implementation.

Random but Smooth

Noise is an important building block for adding natural-looking variety to procedural textures. In the real world, nothing is perfectly uniform, and noise provides a controlled way of adding this randomness to your shaders.

The noise function has several ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Mathematics for Game Programming and Computer Graphics

Publisher Resources

ISBN: 9780321545411Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

GPU Gems 2: Programming Techniques for High-Performance Graphics and General-Purpose Computation

by Matt Pharr, Randima Fernando

Chapter 26. Implementing Improved Perlin Noise

Random but Smooth

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.