Unit 1
Introduction to Computer
Graphics
Using computers to create, manipulate, and display visual content—from
images to interactive scenes. Leveraging the brain's visual processing power
(30% dedicated to vision) to enhance human-computer interaction through
art, mathematics, and engineering.
Definition:
Computer graphics fundamentally involves generating visual representations using
computational methods, bridging the gap between abstract data and human perception. It
leverages the human visual system's efficiency—processing images 60,000 times faster
than text—to convey complex information intuitively. Beyond visuals, it sometimes
integrates multisensory elements like haptics or audio for immersive experiences. The
field's evolution stems from the need to visualize computational outputs, starting from
early mechanical plotters in the 19th century to modern GPU-accelerated rendering.
[Link]
Dr. Wanbanker Khongbuh
HISTORY
Evolution of Computer Graphics
1950s–1960s 1
CRT graphics and Sketchpad (1963) introduced visual input
via light pens
2 1970s
Arcade games popularized rasterized graphics; University of
Utah pioneered 3D shading models
1980s 3
Personal computers with GUIs emerged; Pixar's Luxo Jr.
showcased animation progress
4 1990s
OpenGL standardized GPU control for 3D pipelines
2000s 5
Programmable shaders enabled custom GPU programs
6 2010s–Present
Real-time ray tracing with hardware acceleration allows
photorealistic rendering
[Link]
Historical expansions
• Pre-1950s Roots: Artistic techniques like perspective projection (Alberti's 1435 treatise) and descriptive geometry (Monge,
1799) laid mathematical foundations. Early devices included the 1801 Jacquard loom for patterned weaving and 1940s
analog computers for ballistic trajectories.
• 1950s–1960s Advancements: Whirlwind I (1951) used CRT for real-time displays in air defence. SAGE system (1958)
introduced interactive graphics with light guns. Sutherland's Sketchpad (1963) pioneered object-oriented concepts,
constraints, and rubber-banding for dynamic editing.
• 1970s Innovations: Raster graphics dominated with games like Pong (1972). Hidden-surface removal algorithms (e.g.,
Watkins, 1970) enabled realistic 3D. University of Utah's contributions included Catmull's texture mapping (1974) and Blinn's
bump mapping (1978).
• 1980s Commercialization: Silicon Graphics workstations (1982) popularized hardware acceleration. Ray tracing by Whitted
(1980) simulated global illumination. Pixar's RenderMan (1988) standardized shading languages.
• 1990s Standardization: SGI's OpenGL (1992) unified APIs. Quake (1996) showcased real-time 3D engines. Wavelet-based
compression improved texture handling.
• 2000s Programmability: NVIDIA's GeForce 3 (2001) introduced vertex/pixel shaders. GPGPU emerged with CUDA (2006),
enabling non-graphics computations.
• 2010s–Present Real-Time Realism: RTX series (2018) integrated ray tracing cores. AI-driven techniques like DLSS (Deep
Learning Super Sampling) upscale frames. Metaverse concepts (e.g., Roblox, 2020s) push procedural generation.
[Link]
HISTORY
To be Noted
The mainframe modules have been
extended to realism (photorealism via path
tracing), interactivity (VR/AR), and
accessibility (e.g., graphics for visually
impaired via sonification). Overlaps: Image
processing focuses on analysis (e.g., edge
detection), while vision extracts semantics
(e.g., object recognition). Challenges
include computational cost and ethical
issues like deepfakes.
[Link]
Core Graphics Areas
Computer graphics encompasses diverse subfields,
each addressing specific challenges in visual
Rendering Geometry computing. Rendering and geometry form the
Produce final Model shapes and foundation, while other areas build specialized
images from scene meshes that feed applications.
data, linking to rendering and
geometry. simulation.
These domains often overlap—rendering requires
geometry, visualization uses image processing, and
animation combines physics with geometry.
Image/Video Physics
Process pixels and Simulate dynamics
sequences to that inform
refine rendered geometry and
output. visualization.
[Link]
Graphics areas categorize the discipline into interconnected domains, facilitating specialized research and application. These are not
rigid but evolve with technology, such as AI integration in all areas.
Detailed sub-areas:
• Rendering: Core to image synthesis. Offline methods (e.g., Monte Carlo ray tracing) prioritize accuracy; real-time (rasterization) Favors
speed. Advanced topics: Global illumination models (radiosity, photon mapping), volumetric rendering (clouds, smoke), and non-
photorealistic rendering (NPR) for artistic styles like cel-shading.
• Geometry Processing: Involves acquisition (scanning, photogrammetry), editing (deformation, Boolean operations), and analysis
(curvature, topology). Tools: MeshLab for processing, Blender for modelling. Subdivision surfaces (Loop, Catmull-Clark) refine coarse
meshes smoothly.
• Image/Video Processing: Includes filtering (Gaussian blur), compositing (alpha blending), and compression (JPEG, H.265). Applications:
Video stabilization, HDR merging. Deep learning enhances super-resolution (e.g., ESRGAN).
• Physics Simulation and Animation: Rigid body dynamics (Bullet Physics engine), soft bodies (cloth simulation via mass-spring models),
fluids (SPH or Eulerian methods). Animation techniques: Forward/inverse kinematics for characters, particle systems for effects. Motion
capture (MoCap) uses markers or markerless AI (e.g., DeepMoCap).
• Visualization: Scientific (isosurfaces for MRI data), information (treemaps for hierarchies), and visual analytics (interactive dashboards).
Principles: Tufte's data-ink ratio for minimalism. Tools: Tableau, ParaView.
• Fabrication and Interaction: Additive manufacturing (STL file formats), haptic feedback (force/tactile devices). VR/AR: Head-mounted
displays (Oculus), gesture recognition (Leap Motion). Human-computer interaction (HCI) principles like Fitts's law optimize interfaces.
• Sound Synthesis: Physically based (waveguide models for instruments), procedural (FM synthesis). Synchronization with visuals in
games/films via middleware like FMOD. [Link]
HISTORY
To be Noted
Emerging areas: AI graphics (GANs for texture generation),
computational photography (light fields), and sustainable
graphics (energy-efficient algorithms).
[Link]
Major Applications Across Industries
Computer-Aided Design Entertainment Visualization Education & Training
Films (24 fps), games, Analyzing scientific, Simulations like flight or
Engineering and animations using medical, and business data ship piloting with
architecture with photorealistic techniques by converting volumes into generated models for
wireframe displays, multi- and morphing for visual forms for efficient immersive learning
window views, and commercial art analysis experiences
performance-testing
animations
[Link]
Applications demonstrate graphics' versatility, driving economic value (e.g., $100B+ gaming industry) and societal impact (e.g.,
medical simulations saving lives).In-depth examples:
• CAD: Parametric modelling in AutoCAD/SolidWorks allows constraint-based designs. Finite element analysis (FEA) visualizes stress.
Automotive: Virtual prototyping reduces physical models.
• Presentation Graphics: Tools like PowerPoint use vector graphics for scalability. Data visualization: Infographics with [Link] for web
interactivity.
• Computer Art and Entertainment: Digital painting (Photoshop brushes simulate oils). CGI in films: Jurassic Park (1993) pioneered
dinosaur animations. Games: Unreal Engine's Nanite for massive detail. VR experiences like Beat Saber.
• Education and Training: Serious games for skill-building (e.g., surgical simulators). E-learning platforms with interactive 3D models .
• Visualization: Medical: Volume rendering for CT scans. Weather: Animated simulations of hurricanes. Business: Heatmaps for sales
data.
• Image Processing: Enhancement (contrast adjustment), restoration (inpainting damaged photos). AI applications: Face recognition
in security.
• GUIs: Modern frameworks (Qt, WPF) support responsive design. Accessibility features: High-contrast modes.
• Space and Scientific: NASA's Voyager animations used procedural terrains. Molecular visualization in chemistry (PyMOL for
proteins).
• Additional Applications: Advertising (3D product renders), forensics (crime scene reconstructions), cultural heritage (virtual
museum tours like Google Arts & Culture).
[Link]
TECHNICAL
Graphics APIs: Controlling the GPU
OpenGL
Cross-platform API for GPU control with
programmable shaders (vertex and
fragment). Acts as state machine for
rasterization pipelines
Vulkan
Modern, low-level API for finer GPU
control in real-time applications with
enhanced performance
Direct3D
Microsoft-specific API similar to OpenGL
for 3D rendering pipelines on Windows
platforms
[Link]
APIs abstract hardware complexities, enabling portable code. They
evolve toward lower-level access for performance.
Detailed features:
• OpenGL: Immediate mode (legacy) vs. retained (modern). Shaders in
GLSL: Vertex (transforms, lighting), geometry (tessellation), fragment
(texturing). Extensions via GLEW. Debugging: glGetError(). Web variant:
WebGL for browsers.
• Direct3D: Part of DirectX; versions 11+ support compute shaders. HLSL
language. Integration with Windows ecosystems (Xbox).
• Vulkan: Explicit memory management, multi-threading. Reduces driver
overhead. Used in DOOM (2016) for high FPS.
• Metal: Apple-specific, low-overhead for iOS/macOS.
• Supporting Ecosystems: GLFW for cross-platform windows. Assimp for
model loading (OBJ, FBX formats). Shader compilation: SPIR-V
intermediate for Vulkan.
• Evolution: Fixed-function (OpenGL 1.x) to core profile (3.3+),
emphasizing buffers (VBOs, EBOs for indices). Uniforms for passing data
to shaders.
[Link]
3D Geometric Models
Representing objects in space requires diverse mathematical approaches, from simple polygons to complex curves.
Polygon Meshes Quadric Surfaces
Triangle meshes with vertices (x, y, z) and normals. Most Defined by quadratic equations for shapes like spheres
common for APIs like OpenGL using homogeneous and cylinders
coordinates
Spline Representations Hierarchical Models
Hermite, Bezier, and B-Spline curves for smooth Scene graphs organize models with parent-child relations
interpolation using control points and transformation matrices
[Link]
Models define shape, appearance, and behaviour in virtual spaces. Representations balance accuracy, efficiency, and editability.
Elaborated types:
• Polygon Meshes: Triangles preferred for simplicity in rasterization. Topology: Manifold vs. non-manifold. Storage: Indexed faces
to save memory.
• Quadric Surfaces: Implicit equations (e.g., sphere: x² + y ² + z² = r ²). Ray intersection easy for rendering.
• Splines: Parametric curves. Hermite: Cubic with continuity. Bezier: Bernstein basis, de Casteljau algorithm for evaluation. B-
Splines: Uniform/non-uniform, NURBS add weights for conics.
• Procedural Models: Fractals (Mandelbrot for terrains), L-systems for plants.
• Hierarchical Modelling: Transforms: Scale, rotate (quaternions avoid gimbal lock), translate. Composite matrices multiplied in
reverse order.
• Coordinate Systems: Local (object), world, view (camera), clip (NDC after projection), screen. Handedness: Right (OpenGL) vs.
left.
Acquisition: 3D scanning (LiDAR), modelling software (Maya). Optimization: Level of detail (LOD) for distant objects.
[Link]
The Graphics Pipeline
From 3D Data to 2D Images
The pipeline transforms 3D geometry
into rendered pixels through
Vertex Transform programmable stages.
• Vertex Processing: Transforms
Rasterization vertices via model-view matrix
(programmable)
Fragment Shade • Rasterization: Projects geometry to
pixels, interpolates attributes (fixed)
• Fragment Processing: Shades
Output Test fragments with custom programs
(programmable)
• Output: Z-buffer depth testing keeps
closest fragments
[Link]
The pipeline is a staged process, highly parallelized on GPUs for throughput.
Detailed stages:
• Application Stage: CPU-side: Scene setup, culling (frustum, occlusion).
• Geometry Stage: Vertex shader (MVP matrix: Model-View-Projection), primitive assembly,
clipping against view volume.
• Rasterization: Scan conversion, barycentric interpolation. Anti-aliasing: MSAA (multi-
sample).
• Fragment Stage: Fragment shader (texture sampling, lighting calculations). Per-fragment
operations: Stencil testing.
• Framebuffer Operations: Blending (Porter-Duff compositing), dithering.
• Alternative Pipelines: Ray tracing: Primary rays from camera, secondary for
shadows/reflections. Hybrid: Rasterize + ray trace reflections.
• Viewing Transformations: Orthographic for isometric views, perspective for realism
(foreshortening). GluPerspective/glFrustum functions.
Bottlenecks: Fill rate (pixels/sec), vertex throughput. Profiling tools: NVIDIA Nsight.
[Link]
Numerical Challenges
Aliasing Floating-Point Gimbal Lock
Jagged edges from Precision Loss of rotation
under-sampling; Errors in matrix freedom in Euler
mitigated by anti- operations and angles; prefer
aliasing or higher normalizations; use quaternions for
resolution homogeneous stability
coordinates
Z-Buffer Precision
Limited depth resolution; use logarithmic mapping for better distribution
[Link]
Arise from discrete sampling, finite precision (IEEE 754 floats), and algorithmic approximations.
Specific problems and solutions:
• Aliasing: Spatial (jaggies), temporal (wagon-wheel effect). Supersampling, FXAA/MLAA post-processing.
• Precision Errors: Catastrophic cancellation in subtractions. Use double precision where needed.
• Gimbal Lock: Euler angles singularity. Quaternions: Slerp for interpolation.
• Z-Fighting: Overlapping surfaces flicker due to depth precision. Offset polygons or increase bit depth.
• Division by Zero: In projections; clip before divide.
• Interpolation Artifacts: Linear in screen space warps textures; perspective-correct via 1/w.
• Overflow/Underflow: In exponentiations (e.g., attenuation). Clamp values.
• Numerical Stability: In matrices: Orthogonalization (Gram-Schmidt), condition numbers.
Tools: Arbitrary-precision libraries (GMP), error analysis techniques.
[Link]
Challenge Primary Cause Common Symptom
Z-Fighting Depth buffer precision Flickering overlapping textures
Shadow Acne Ray-surface intersection error Moiré patterns in shadows
Simulation Explosion Unstable ODE integration Mesh vertices flying to infinity
Fireflies Monte Carlo variance Bright, isolated pixels in renders
Jittering Floating-point drift far from origin Shaking models or "jumpy" movement
[Link]
Optimization for Efficiency
Critical for real-time (60+ FPS) vs. offline rendering. Metrics: Time complexity, memory footprint, power consumption.
Maximize performance through smart algorithms, hardware utilization, and memory management.
Optimization strategies:
• Algorithmic: Bresenham's line algorithm uses integer operations; incremental updates minimize calculations. Midpoint
circle algorithm (integer-based). Spatial partitioning (octrees, BSP trees) for scene queries.
• Hardware Utilization: GPUs parallelize fragment shading at 60–80 Hz refresh rates with programmable shaders.
• Memory: Shared geometries reduce redundancy; static buffers for immutable data improve performance.
• Rendering Techniques: Deferred shading (separate geometry/lighting passes) for many lights. Shadow mapping vs.
volumes.
• Animation: Skeletal animation (bone hierarchies), blending for smooth transitions.
• System-Level: Double buffering to avoid tearing. VSync for smooth refresh.
• Trade-offs: Quality vs. speed (e.g., bilinear vs. trilinear filtering). Mobile: Power-aware scaling.
Profiling: RenderDoc for captures, GPU-Z for metrics. Future: AI-accelerated culling.
[Link]