Computer graphics pipelines model virtual worlds using continuous mathematical spaces. These continuous spaces contain geometric primitives such as points, lines, polygons, and complex splines. Physical display monitors and raster buffers possess finite spatial dimensions and discrete pixel grids. Mapping an unconstrained world model to a constrained display surface requires determining which graphical elements fall within the viewer's field of view and which fall outside it.

Clipping is the foundational computational process that isolates and extracts graphical primitives located within a specified region of interest while discarding elements outside it. Without clipping, rasterization hardware would waste processing cycles projecting objects located behind the viewer or beyond the boundaries of the display monitor. Attempting to draw coordinates that exceed frame buffer boundaries can cause memory access violations and buffer overflow errors in low-level graphics drivers.

This chapter establishes the theoretical principles and practical algorithms of geometric clipping. The content moves from basic spatial definitions and coordinate system transformations to advanced line and polygon clipping algorithms. Understanding these mechanisms reveals how modern graphics hardware manages spatial boundaries, optimizes rendering pipelines, and handles interactive viewport display transformations.

3.1 Introduction to Clipping

Graphic rendering systems must decide which portions of a virtual scene to show on a monitor and which portions to remove. Clipping resolves this problem by evaluating geometric primitives against defined spatial boundaries before rasterization occurs. Building a complete understanding of clipping requires exploring core definitions, mapping terminology, primitive classifications, and real-world system applications.

Fundamental Concepts of Graphic Clipping

Computer graphics applications construct scenes inside continuous Cartesian coordinate spaces called world coordinate systems. A user or camera selects a specific rectangular window inside this world to view a portion of the scene. Graphical primitives often extend beyond the boundaries of this selected viewing region.

Definition and Purpose

Clipping is the algorithmic process of identifying and removing portions of graphics primitives that lie outside a designated spatial boundary. The primary purpose of clipping is to restrict rendering calculations strictly to primitives visible within the designated viewing frame.

graph TD
    A[World Coordinate Scene] --> B{Clipping Engine}
    B -->|Inside Boundary| C[Visible Primitive Segment]
    B -->|Outside Boundary| D[Discarded Geometry]
    C --> E[Rasterization & Viewport Display]
    
    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#64748b,color:#f8fafc
    style C fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style D fill:#7f1d1d,stroke:#ef4444,color:#f8fafc
    style E fill:#1e293b,stroke:#475569,color:#f8fafc

When a geometric object intersects a clipping boundary, the clipping engine calculates the exact spatial intersection points. The algorithm trims the original primitive, generates new boundary endpoints, and removes the invisible line segments or polygon fragments. The resulting truncated primitive preserves geometric fidelity while strictly respecting the display border.

Importance in Graphics Pipelines

Clipping operates early in the execution sequence of graphics pipelines, sitting directly between geometric coordinate transformations and primitive rasterization. Executing clipping prior to rasterization yields three main computational advantages:

Computational Efficiency: Scan-converting primitives into individual pixels requires intensive memory and processing resources. Pruning non-visible primitives early prevents the engine from generating off-screen fragments.
Buffer Overflow Prevention: Display frame buffers map directly to fixed hardware memory addresses. Rendering coordinates that lie outside these memory bounds leads to buffer wrapping or program crashes.
Memory Bandwidth Optimization: Modern GPU architectures rely on memory bandwidth to stream vertex data. Removing invisible primitives cuts down data transfer across PCI buses and system memory channels.

Core Terminology and Spatial Representations

Precise spatial representations form the backbone of graphics boundary evaluations. Five foundational terms define how geometry moves from an abstract world into physical display space.

The World Coordinate Clipping Window

The world coordinate clipping window (often called the clipping window) is a rectangular region defined in the world coordinate system that specifies the exact scene content selected for viewing. Mathematically, the clipping window is defined by four coordinate limits:

Any point located within these boundaries satisfies the following system of inequalities:

The Screen Coordinate Viewport

The screen coordinate viewport (or simply viewport) is a designated rectangular region on the display device where the contents of the clipping window are mapped and rendered. While the clipping window defines what scene content is selected in world units, the viewport defines where and at what scale that content appears on the physical screen buffer. The viewport boundaries are specified using device coordinate limits:

The Clipping Boundary

The clipping boundary refers to the mathematical planes or line segments that enclose the clipping window. In two-dimensional rectangular clipping, the clipping boundary consists of four distinct edge lines:

Left Boundary:
Right Boundary:
Bottom Boundary:
Top Boundary:

These four boundary lines divide two-dimensional space into nine distinct structural regions, establishing the spatial framework used by clipping algorithms to classify point and line positions.

The Visible Region

The visible region is the interior spatial domain located strictly inside or along the borders of all active clipping boundaries. Geometric elements positioned entirely within this region pass through the clipping pipeline without modification. Elements spanning across the visible region boundaries are truncated to fit inside.

Taxonomy of Printable Primitives

Clipping algorithms vary in complexity depending on the underlying geometric primitive being processed. Graphics systems support five primary categories of printable primitives.

graph LR
    A[Clippable Primitives] --> B[Point Clipping]
    A --> C[Line Clipping]
    A --> D[Curve Clipping]
    A --> E[Polygon Clipping]
    A --> F[Text Clipping]
    
    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#475569,color:#f8fafc
    style C fill:#334155,stroke:#475569,color:#f8fafc
    style D fill:#334155,stroke:#475569,color:#f8fafc
    style E fill:#334155,stroke:#475569,color:#f8fafc
    style F fill:#334155,stroke:#475569,color:#f8fafc

Point Clipping

Point clipping evaluates isolated coordinates against the rectangular clipping window. The operation evaluates the spatial inequalities directly. If a point satisfies and , the graphics system retains the point for display; otherwise, it discards the coordinate. Point clipping requires zero intersection calculations, making it computationally light.

Line Clipping

Line clipping processes continuous segment primitives defined by two endpoints and . The algorithm determines whether the line segment lies entirely inside the window, entirely outside, or intersects one or more clipping boundaries. When an intersection occurs, the algorithm solves parametric or linear equations to locate the boundary intersection point and updates the segment endpoints accordingly.

Curve Clipping

Curve clipping processes non-linear primitives such as circles, ellipses, and continuous splines. The clipping algorithm evaluates the curve's bounding box against the window limits. If the bounding box intersects the boundary, the engine solves polynomial equations to find precise boundary intersection points. Because non-linear polynomial equations are computationally expensive to solve, systems frequently approximate curves using fine sequences of linear line segments before running line clipping operations.

Polygon Clipping

Polygon clipping processes filled planar shapes bounded by connected sequences of line edges. Unlike line clipping—which produces disconnected line segments—polygon clipping must return closed polygonal regions. Clipping a polygon can alter its overall vertex count or split a single concave shape into multiple separate polygons. The pipeline evaluates each edge in sequence and outputs a modified array of ordered vertices.

Text Clipping

Text clipping manages string primitives and character glyphs. System architectures process text clipping using three distinct strategies based on performance demands:

All-or-Nothing Character Clipping: The engine calculates the bounding box for an entire text string. If any portion of the string box crosses the window border, the system discards the entire string.
All-or-Nothing Glyph Clipping: The engine evaluates bounding boxes for individual characters. Characters that fit inside the window are rendered, while characters that cross the border are discarded.
Detailed Stroke Clipping: The system breaks individual character glyphs down into underlying line segments and curves, applying line and curve clipping to individual strokes. This approach produces partially clipped letters along screen edges at the cost of higher processing times.

Domain Applications of Spatial Clipping

Spatial clipping is a core requirement across computer graphics and software engineering domains. This operational pipeline encompasses five primary application areas:

Interactive Computer Graphics: Modern rendering engines use view frustum culling and two-dimensional viewport clipping to filter out objects positioned outside the camera's field of view. This processing keeps frame rates smooth during real-time rendering.
Computer-Aided Design (CAD) Systems: Engineering packages manage large schematics containing millions of vector lines. CAD software uses clipping to extract and display specific component sub-assemblies when users zoom into detailed mechanical drawings.
Geographic Information Systems (GIS): GIS engines store regional vector maps with complex road networks and topographic outlines. Spatial clipping limits database queries and screen rendering to specific geographic coordinates during interactive panning and zooming.
Computer Games: Game engines split screen real-time viewports for multiplayer modes and manage mini-map overlays. Spatial clipping isolates rendering contexts, preventing mini-map graphics from bleeding into main gameplay viewports.
User Interface Design: Graphical windowing environments depend on spatial clipping to keep application content contained within scrollable frames and movable windows. The operating system clips background graphics to prevent overlapping windows from overwriting foreground content.

3.2 Window to Viewport Transformation

Scenes are designed inside infinite world coordinate systems using units appropriate for the domain, such as meters, light-years, or micrometers. Display monitors display images using fixed two-dimensional raster grids measured in physical pixels. The bridge between continuous world space and physical screen coordinates is the window-to-viewport transformation.

Foundations of Coordinate Mapping

Window-to-viewport transformation maps object coordinates from the world clipping window to the display viewport. This process maps world locations into device space while preserving the structural spatial relationships of the rendered scene.

graph LR
    A[World Coordinate Window] -->|Scale & Translate| B[Normalized Device Coordinates]
    B -->|Device Mapping| C[Display Device Viewport]
    
    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#64748b,color:#f8fafc
    style C fill:#0f766e,stroke:#14b8a6,color:#f8fafc

Concept and Purpose

The primary purpose of window-to-viewport transformation is to map a selected coordinate range inside a world window into a target coordinate space inside a display viewport. This operation scales object geometries so that world features fill the allocated viewport area cleanly.

Structural Role in the Rendering Pipeline

The transformation acts as a bridge between high-level geometry definition and hardware rasterization. Modern graphics pipelines execute this transformation after geometric clipping finishes. Clipping non-visible primitives in world coordinates avoids applying transformation matrix calculations to discarded geometry.

Geometric Characterization of Windows and Viewports

To establish mathematical mapping equations, systems define the exact geometric bounds of both coordinate frames.

The World Coordinate Window

The world coordinate window is defined by its minimum and maximum horizontal and vertical bounds:

The total width and height of the world clipping window are calculated as:

The Display Viewport

The display viewport is defined by its corresponding device coordinate bounds:

The total width and height of the display viewport are calculated as:

Mathematical Derivation of Mapping Equations

Mapping a point from world space to a viewport point requires preserving relative spatial proportions within both boundaries.

Scaling Factors and Linear Mapping

The relative horizontal position of a point inside the world window must match its relative horizontal position inside the display viewport:

Similarly, matching vertical spatial ratios yields:

Defining the horizontal scaling factor and vertical scaling factor :

Where:

: Minimum X-coordinate of the world window.
: Maximum X-coordinate of the world window.
: Minimum Y-coordinate of the world window.
: Maximum Y-coordinate of the world window.
: Minimum X-coordinate of the display viewport.
: Maximum X-coordinate of the display viewport.
: Minimum Y-coordinate of the display viewport.
: Maximum Y-coordinate of the display viewport.
: Horizontal scaling factor between window and viewport.
: Vertical scaling factor between window and viewport.

Coordinate Mapping Formulations

Solving the ratio equations directly yields the point mapping equations for and :

Matrix Formulation of Window-to-Viewport Mapping

The transformation maps points through three sequential geometric steps:

Translate the world window origin to the world coordinate origin .
Scale the translated geometry by scaling factors .
Translate the origin to the display viewport origin .

Using homogeneous coordinates, these three operations combine into a single composite matrix operator :

Expanding this sequence using matrix multiplication yields:

Multiplying the scaling matrix by the initial translation matrix:

Multiplying by the final translation matrix produces the composite transformation matrix:

Applying this matrix to a world coordinate vector yields the final viewport coordinate position:

Worked Numerical Problem 1: Standard Window-to-Viewport Point Mapping

Problem Statement: A world coordinate window has its lower-left corner at and its upper-right corner at . The target viewport on a display screen has its lower-left corner at and its upper-right corner at . Map the world point to its corresponding viewport coordinates .

Step 1: Identify given coordinate boundaries.

World point:

Step 2: Calculate horizontal scaling factor .

Step 3: Calculate vertical scaling factor .

Step 4: Compute transformed coordinate.

Step 5: Compute transformed coordinate.

Final Result: The world point maps to viewport coordinates .

Worked Numerical Problem 2: Distortion Analysis Under Aspect Ratio Mismatch

Problem Statement: A CAD engine defines a square world window with bounds . The viewport is configured on a widescreen display buffer with bounds . Calculate the transformed viewport positions for the four square vertices , , , and , and determine whether geometric distortion occurs.

Step 1: Identify given coordinate boundaries.

Step 2: Calculate scale factors and .

Step 3: Map Vertex 1 .

Step 4: Map Vertex 2 .

Step 5: Map Vertex 3 .

Step 6: Map Vertex 4 .

Step 7: Evaluate geometric distortion.
The original object is a square with equal side lengths (). In the display viewport, the transformed horizontal side length is pixels, while the vertical side length is pixels. Because (), non-uniform scaling occurs, distorting the original square into a rectangle with a aspect ratio. To preserve aspect ratio, systems must enforce .

Operational Applications of Coordinate Transformation

Window-to-viewport transformations enable essential user interface operations across graphic software packages.

Interactive Zooming

Zooming alters the scale of displayed objects by adjusting the world window dimensions while keeping the viewport size fixed:

Zooming In: Shrinking the world window decreases the denominators in the scaling equations. This increases and , causing a smaller world region to fill the entire viewport and making scene objects appear larger.
Zooming Out: Expanding the world window increases the denominators, reducing and . This projects a larger portion of the world scene into the viewport, making objects appear smaller.

Interactive Panning

Panning translates the position of the world window across world space while keeping the window dimensions and display viewport fixed. Updating shifts the selected viewing area, sliding the visible scene across the display frame without altering object scale.

Display Mapping Across Heterogeneous Hardware

Different output devices (such as high-resolution monitors, mobile screens, or plotters) feature varying display bounds and pixel densities. Graphics software uses window-to-viewport mapping to project a single world scene onto multiple different viewports simultaneously without altering the underlying world data.

3.3 Line Clipping

Line clipping isolates line segments positioned inside a rectangular window and trims segments that cross its boundaries. Developing an efficient line clipping architecture requires analyzing basic spatial cases, defining boundary conditions, establishing intersection formulas, and reviewing common system applications.

Fundamental Mechanics of Line Segment Clipping

Line segment clipping evaluates straight lines defined by endpoints and against a rectangular clipping window .

Concept and Purpose

The primary goal of line clipping is to compute the visible portion of a line segment within a rectangular viewing region. If a segment crosses a boundary, the algorithm calculates the exact intersection coordinate and truncates the line, discarding non-visible segment portions.

Role in Geometric Pruning

Line clipping reduces the computational workload of scan conversion algorithms. Without line clipping, line drawing algorithms (such as Bresenham's or DDA) would waste processing cycles calculating pixel coordinates for off-screen segments.

Spatial Visibility Classifications

Line segments fall into three distinct spatial classifications relative to a rectangular window:

graph TD
    A[Line Segment Classification] --> B[Completely Visible]
    A --> C[Completely Invisible]
    A --> D[Partially Visible]
    
    B --> E[Both Endpoints Inside]
    C --> F[Both Endpoints Outside on Same Side]
    D --> G[One or Both Endpoints Outside Intersecting Window]
    
    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style C fill:#7f1d1d,stroke:#ef4444,color:#f8fafc
    style D fill:#d97706,stroke:#f59e0b,color:#f8fafc
    style E fill:#1e293b,stroke:#475569,color:#f8fafc
    style F fill:#1e293b,stroke:#475569,color:#f8fafc
    style G fill:#1e293b,stroke:#475569,color:#f8fafc

Completely Visible Lines

A line segment is completely visible (or trivially accepted) if both endpoints and lie inside the clipping window:

The algorithm retains the segment in its entirety without performing intersection calculations.

Completely Invisible Lines

A line segment is completely invisible (or trivially rejected) if it lies entirely outside the visible region. A segment can be trivially rejected if both endpoints lie beyond the same outer boundary (for instance, if both endpoints lie entirely to the left of , where and ). The algorithm discards these segments immediately without calculating intersections.

Partially Visible Lines

A line segment is partially visible if it intersects one or more clipping boundaries. This case occurs when:

One endpoint lies inside the window and the other endpoint lies outside.
Both endpoints lie outside the window, but the connecting segment passes through the interior visible region.

Partially visible lines require calculating intersection coordinates along window boundaries to trim invisible segment portions.

Visibility Classification Comparison

The structural properties of these three spatial visibility states are summarized in the following table:

Classification Attribute	Completely Visible	Completely Invisible	Partially Visible
Endpoint Location	Both endpoints inside window	Both endpoints outside window	One inside/one out, or both out
Intersection Steps	Zero intersection calculations	Zero intersection calculations	1 to 2 boundary intersections
Pipeline Action	Retain line segment completely	Reject line segment completely	Truncate and update endpoints
Computational Cost	Very Low (Inequality check)	Low (Early rejection test)	High (Requires slope algebra)
Output State	Unmodified line segment	Discarded geometry	Trimmed line segment
Boundary Crossings	0 boundary crossings	0 interior boundary crossings	1 or 2 boundary crossings

Boundary Equations and Parametric Intersection Algebra

Calculating line intersections along the four window boundaries uses standard slope-intercept line algebra. A non-vertical line segment defined by and has a slope :

The equation of the line segment expressed in point-slope form is:

Clipping Boundary	Fixed Coordinate	Intersection Formula
Left Edge
Right Edge
Bottom Edge
Top Edge

Left and Right Boundary Intersection Formulations

For vertical boundaries where is constant ( or ), substituting the fixed position into the slope equation gives the corresponding vertical intersection coordinate :

Left Boundary ():
Right Boundary ():

Bottom and Top Boundary Intersection Formulations

For horizontal boundaries where is constant ( or ), substituting the fixed position into the slope equation gives the corresponding horizontal intersection coordinate :

Bottom Boundary ():
Top Boundary ():

Worked Numerical Problem 1: Analytical Intersection with Boundary Edges

Problem Statement: A rectangular window is defined by . A line segment has endpoints and . Calculate the slope , locate the boundary intersection points, and determine which boundary the line intersects first when moving from toward .

Step 1: Calculate segment slope .

Step 2: Evaluate endpoint position.

lies to the left of the left boundary.
, which lies between and .

Step 3: Calculate intersection with the Left Boundary ().

Since , the intersection point lies on the valid left boundary segment.

Step 4: Evaluate endpoint position.

, which lies between and .
lies above the top boundary.

Step 5: Calculate intersection with the Top Boundary ().

Since , the intersection point lies on the valid top boundary segment.

Final Result: Moving from to , the line enters the visible window through the left boundary at and exits through the top boundary at .

Worked Numerical Problem 2: Segment Truncation for Partially Visible Line

Problem Statement: A line segment with endpoints and is clipped against a window defined by . Calculate the updated endpoints for the clipped segment.

Step 1: Calculate segment slope .

The slope indicates a horizontal line running along .

Step 2: Check horizontal containment.
The line's vertical position lies inside . The line crosses the window horizontally.

Step 3: Clip against the Left Boundary ().
Because , lies outside the left edge. The intersection point retains and takes the boundary coordinate :

Step 4: Clip against the Right Boundary ().
Because , lies outside the right edge. The intersection point retains and takes the boundary coordinate :

Final Result: The line segment is truncated to and , leaving a visible segment length of units inside the window.

Analytical Line Clipping Pipeline

Execution of standard line clipping algorithms follows a three-phase sequence:

Visibility Determination Phase: The engine evaluates endpoint coordinates against boundary inequalities to identify completely visible or completely invisible lines early.
Intersection Calculation Phase: For partially visible lines, the algorithm identifies which window boundaries the line intersects and calculates the precise intersection points using slope algebra.
Segment Truncation Phase: The algorithm replaces original off-screen endpoints with the newly computed boundary intersection points. It re-evaluates the updated segment to confirm it fits entirely inside the visible window.

Application Domains for Line Clipping

Line clipping algorithms are integrated into real-world vector rendering systems:

Interactive Vector Graphics: Graphic design software (such as SVG viewers or vector editors) uses line clipping to crop vector paths, wireframes, and strokes against the artboard canvas.
Industrial CAD Wireframe Engines: CAD systems process 3D wireframe models made up of thousands of line segments. Line clipping algorithms quickly trim off-screen vector lines, accelerating rendering during real-time pan and zoom operations.
GIS Vector Mapping: GIS platforms render extensive road networks and administrative boundaries stored as vector polylines. Spatial line clipping restricts primitive rendering strictly to the active map canvas view, maintaining fast screen redraw speeds.

3.4 Cohen–Sutherland Line Clipping Algorithm

The Cohen–Sutherland algorithm is one of the oldest and most widely used line clipping techniques in computer graphics. It accelerates line clipping by dividing two-dimensional space into nine regions using 4-bit region codes called outcodes. By performing fast bitwise operations on these outcodes, the algorithm rapidly accepts or rejects line segments without calculating expensive floating-point intersections. Understanding this algorithm requires examining its region coding system, bitwise visibility logic, boundary algebra, execution pipeline, and solved numerical problems.

Foundations of the Cohen–Sutherland Algorithm

Calculating line intersections using floating-point division is computationally expensive. In typical graphical scenes, most line segments lie either completely inside or completely outside the clipping window.

Algorithmic Purpose and Design Goals

The primary goal of the Cohen–Sutherland algorithm is to minimize floating-point intersection calculations. The algorithm assigns a 4-bit binary code to every line endpoint based on its spatial location relative to the window boundaries. Comparing these binary codes using CPU bitwise operators allows the system to identify trivially visible and trivially invisible lines instantly. Intersection algebra is reserved exclusively for partially visible lines that cross window borders.

Architectural Advantages in Pipeline Processing

Graphics processors execute bitwise operations (such as bitwise AND, OR, and NOT) in a single clock cycle. Floating-point division operations require significantly more processor cycles. By replacing geometric floating-point checks with integer bit testing, the Cohen–Sutherland algorithm speeds up rendering pipelines handling dense vector scenes.

9-Region Outcode Spatial Partitioning

Extending the four lines of a rectangular clipping window (, , , and ) partitions two-dimensional space into nine distinct spatial regions.

Bitwise Structure of Region Codes

Each region is assigned a unique 4-bit binary code structured as , commonly abbreviated as the (Top, Bottom, Right, Left) outcode format:

Bit 1 (Top - ): Set to if ; otherwise set to .
Bit 2 (Bottom - ): Set to if ; otherwise set to .
Bit 3 (Right - ): Set to if ; otherwise set to .
Bit 4 (Left - ): Set to if ; otherwise set to .

Bit 1: Top Boundary Bit

The top boundary bit () indicates whether a coordinate lies above the upper edge of the clipping window. When evaluating a point , the algorithm tests the inequality . If true, is set to (representing the bitmask 1000). This bit identifies points situated in the Top-Left, Top, or Top-Right regions.

Bit 2: Bottom Boundary Bit

The bottom boundary bit () indicates whether a coordinate lies below the lower edge of the clipping window. The algorithm evaluates the inequality . If true, is set to (representing the bitmask 0100). This bit identifies points located in the Bottom-Left, Bottom, or Bottom-Right regions.

Bit 3: Right Boundary Bit

The right boundary bit () indicates whether a coordinate lies to the right of the window's right edge. The algorithm evaluates the inequality . If true, is set to (representing the bitmask 0010). This bit identifies points positioned in the Top-Right, Right, or Bottom-Right regions.

Bit 4: Left Boundary Bit

The left boundary bit () indicates whether a coordinate lies to the left of the window's left edge. The algorithm evaluates the inequality . If true, is set to (representing the bitmask 0001). This bit identifies points situated in the Top-Left, Left, or Bottom-Left regions.

Spatial Outcode Assignment Across the 9 Regions

The four boundary bits combine to produce unique bit patterns for each of the nine regions:

Central Window Region (0000): Points inside or on the boundaries of the clipping window satisfy all four coordinate inequalities ( and ). All four bits remain zero, generating the outcode 0000.
Left Edge Region (0001): Points positioned directly to the left of the window (where and ) set only the Left bit, producing 0001.
Right Edge Region (0010): Points positioned directly to the right of the window (where and ) set only the Right bit, producing 0010.
Bottom Edge Region (0100): Points positioned directly below the window (where and ) set only the Bottom bit, producing 0100.
Top Edge Region (1000): Points positioned directly above the window (where and ) set only the Top bit, producing 1000.
Bottom-Left Corner Region (0101): Points located below and to the left of the window ( and ) set both the Bottom and Left bits, producing 0101.
Bottom-Right Corner Region (0110): Points located below and to the right of the window ( and ) set both the Bottom and Right bits, producing 0110.
Top-Left Corner Region (1001): Points located above and to the left of the window ( and ) set both the Top and Left bits, producing 1001.
Top-Right Corner Region (1010): Points located above and to the right of the window ( and ) set both the Top and Right bits, producing 1010.

Bitwise Visibility Testing Logic

Once outcodes and are assigned to line endpoints and , the algorithm executes bitwise tests to classify line visibility.

Trivial Acceptance Test

A line segment is trivially accepted if both endpoints lie inside the clipping window. Mathematically, this condition holds when both outcodes equal 0000:

Performing a bitwise OR operation on and yields 0000 if and only if both endpoints are inside. The algorithm retains the line and skips all intersection calculations.

Trivial Rejection Test

A line segment is trivially rejected if both endpoints lie entirely outside the window on the same side of a boundary plane. This condition occurs when both outcodes share a set bit in the same position:

For example, if has outcode 1001 (Top-Left) and has outcode 1000 (Top), performing a bitwise AND gives 1000 (). The non-zero result proves that both endpoints lie above the top boundary. The line cannot cross the window interior and is discarded immediately.

Partial Acceptance and Iterative Clipping

If a line fails both the trivial acceptance test () and the trivial rejection test (), the segment is partially visible or crosses a window corner.

The algorithm selects an endpoint lying outside the window (an endpoint with an outcode ) and clips it against one crossed boundary edge. The algorithm replaces the outside endpoint with the computed intersection coordinate, recalculates its outcode, and re-runs the bitwise visibility tests. This loop repeats until the line is either accepted or rejected.

Visibility Test Logic Comparison

The properties of these three visibility test states are summarized below:

Test Property	Trivial Acceptance	Trivial Rejection	Partial Acceptance / Clipping
Bitwise Condition			AND
Endpoint States	Both endpoints inside window	Both endpoints share an outside edge	At least one endpoint is outside
Action Taken	Render original segment	Discard line segment	Calculate 1 boundary intersection
Next Step	Pipeline completes	Pipeline completes	Update endpoint outcode and repeat loop
Intersection Steps	0 intersections	0 intersections	1 to 4 boundary intersections
Primary Operator	Bitwise `OR`	Bitwise `AND`	Sequential bitwise testing

Boundary Intersection Formulations

When clipping an outside endpoint with outcode , the algorithm inspects set bits in order () to select a boundary edge for intersection calculation. Using slope :

Left Edge Intersection Calculation

If Bit 4 () is set (), clip against :

Right Edge Intersection Calculation

If Bit 3 () is set (), clip against :

Bottom Edge Intersection Calculation

If Bit 2 () is set (), clip against :

Top Edge Intersection Calculation

If Bit 1 () is set (), clip against :

Algorithmic Execution Pipeline

The complete execution sequence of the Cohen–Sutherland algorithm follows a structured iterative pipeline:

graph TD
    A[Start: Line Endpoints P1, P2] --> B[Compute Outcodes C1, C2]
    B --> C{C1 OR C2 == 0000?}
    C -->|Yes| D[Trivial Accept: Render Line]
    C -->|No| E{C1 AND C2 != 0000?}
    E -->|Yes| F[Trivial Reject: Discard Line]
    E -->|No| G[Select Outside Endpoint C_out != 0000]
    G --> H[Identify Set Boundary Bit in C_out TRBL]
    H --> I[Calculate Intersection Point P_int]
    I --> J[Replace Outside Endpoint with P_int]
    J --> K[Recompute Outcode for P_int]
    K --> B
    D --> L[End]
    F --> L

    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#64748b,color:#f8fafc
    style C fill:#334155,stroke:#64748b,color:#f8fafc
    style D fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style E fill:#334155,stroke:#64748b,color:#f8fafc
    style F fill:#7f1d1d,stroke:#ef4444,color:#f8fafc
    style G fill:#334155,stroke:#64748b,color:#f8fafc
    style H fill:#334155,stroke:#64748b,color:#f8fafc
    style I fill:#334155,stroke:#64748b,color:#f8fafc
    style J fill:#334155,stroke:#64748b,color:#f8fafc
    style K fill:#334155,stroke:#64748b,color:#f8fafc
    style L fill:#1e293b,stroke:#475569,color:#f8fafc

Outcode Initialization: Compute 4-bit outcodes and for and .
Acceptance Test: Check if . If true, render line and exit.
Rejection Test: Check if . If true, discard line and exit.
Endpoint Selection: Choose an endpoint with a non-zero outcode: if , else .
Boundary Clipping: Test set bits in in order () and compute the intersection .
Endpoint Update: Replace the chosen outside endpoint with and update its outcode.
Loop Repeat: Return to Step 2 to re-evaluate the updated line segment.

Performance Characteristics and Limitations

Analyzing algorithmic efficiency highlights where Cohen–Sutherland excels and where performance degrades.

Algorithmic Efficiency and Strengths

High Speed for Extreme Views: When scenes are zoomed in or out, most lines lie entirely inside or entirely outside the window. Bitwise tests eliminate these lines instantly.
Low Memory Footprint: Outcodes store boundary states in a single integer byte per endpoint, using minimal register memory.
Simple Execution Logic: The algorithm uses basic bitwise shifts, comparisons, and slope equations, making it straightforward to implement in both software and hardware.

Computational Limitations

Redundant Iterations for Diagonal Lines: Lines that cross multiple corner regions (such as from Top-Left to Bottom-Right) require up to four separate clipping iterations and intermediate intersection calculations before reaching final acceptance or rejection.
Floating-Point Division Overhead: Every partial clipping pass requires division operations to solve slope equations, introducing floating-point arithmetic delays on CPUs lacking hardware floating-point units.

Step-by-Step Numerical Demonstrations

The following three numerical examples demonstrate trivial acceptance, trivial rejection, and multi-iteration partial clipping.

Worked Numerical Problem 1: Trivially Accepted Line Segment

Problem Statement: A rectangular window is defined by . A line segment has endpoints and . Apply the Cohen–Sutherland algorithm to classify the line segment.

Step 1: Compute outcode for .

Outcode

Step 2: Compute outcode for .

Outcode

Step 3: Execute Bitwise OR Test.

Final Result: The bitwise OR result is 0000. The line segment is trivially accepted and rendered in its entirety without intersection calculations.

Worked Numerical Problem 2: Trivially Rejected Line Segment

Problem Statement: Using the same window (), evaluate a line segment with endpoints and .

Step 1: Compute outcode for .

Outcode (Left region)

Step 2: Compute outcode for .

Outcode (Top-Left corner region)

Step 3: Execute Bitwise Acceptance Test.

(Fails trivial acceptance).

Step 4: Execute Bitwise Rejection Test.

Final Result: The bitwise AND result is 0001 (). The non-zero result confirms that both endpoints lie to the left of . The line is trivially rejected and discarded immediately.

Worked Numerical Problem 3: Partially Clipped Line Segment Across Multiple Boundaries

Problem Statement: A clipping window is defined by bounds . A line segment has endpoints and . Trace the Cohen–Sutherland execution pipeline step by step, computing updated outcodes and intersection points until the final clipped segment is determined.

Step 1: Calculate segment slope .

Step 2: Compute initial outcodes and .

For : . Outcode .
For : ; . Outcode .

Step 3: Execute Bitwise Tests (Iteration 1).

Acceptance: (Pass).
Rejection: (Pass).
The line requires clipping.

Step 4: Execute Iteration 1 Clipping Pass.
Select outside endpoint with outcode . Bit 4 () is set, so clip against Left Boundary ().

Updated endpoint . Recomputing outcode : since and , becomes 0000.

Step 5: Execute Bitwise Tests (Iteration 2).

Acceptance: (Pass).
Rejection: (Pass).
The segment still requires clipping.

Step 6: Execute Iteration 2 Clipping Pass.
Select outside endpoint with outcode . Bit 1 () is set, so clip against Top Boundary ().

Updated endpoint . Recomputing outcode : since and , becomes 0000.

Step 7: Execute Bitwise Tests (Iteration 3).

Both outcodes now equal 0000. The algorithm trivially accepts the truncated line segment.

Final Result: The line segment is clipped to and .

3.5 Polygon Clipping

Line clipping algorithms extract independent line segments, producing disconnected vector strokes. Polygons represent solid filled regions bounded by connected sequences of vertices. Clipping a filled polygon requires modifying its vertex sequence to maintain a closed boundary. Exploring polygon clipping requires examining topological classifications, boundary evaluation cases, intersection reconstruction, and rasterization pipeline applications.

Fundamentals of Polygon Clipping

A polygon is defined by an ordered sequence of vertices connected by directed line edges .

Definition and Structural Challenges

Polygon clipping is the geometric process of intersecting a closed planar polygon with a clipping window to generate one or more updated closed polygons.

Unlike line clipping, polygon clipping cannot simply trim independent edge lines. Trimming polygon edges independently leaves open gaps along the window boundary. These open gaps break polygon fill algorithms, causing rasterization engines to leak colors across the screen. Polygon clipping must compute edge intersections and insert new boundary vertices to close the shape cleanly.

graph TD
    A[Unclipped Input Polygon] --> B{Polygon Clipping Engine}
    B -->|Boundary Intersection| C[Compute Edge Intersections]
    C -->|Reconstruct Loops| D[Insert Window Corner/Boundary Vertices]
    D --> E[Output Closed Polygon Vertex List]
    E --> F[Scanline Area Rasterization]

    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#64748b,color:#f8fafc
    style C fill:#334155,stroke:#64748b,color:#f8fafc
    style D fill:#334155,stroke:#64748b,color:#f8fafc
    style E fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style F fill:#1e293b,stroke:#475569,color:#f8fafc

Purpose and Role in Rasterization Pipelines

In modern rendering pipelines, solid surfaces are represented as collections of planar polygons. Polygon clipping ensures that filled primitives remain closed before passing to scan-conversion algorithms. This step preserves correct surface shading, texture mapping coordinates, and depth-buffer values across display edges.

Topological Classification of Polygons

The internal topology of a polygon dictates how its boundary behaves when intersected by a clipping window. Polygons fall into two main geometric classifications: convex and concave.

graph LR
    A[Polygon Topologies] --> B[Convex Polygon]
    A --> C[Concave Polygon]
    
    B --> D[All Internal Angles <= 180°]
    C --> E[At Least One Reflex Angle > 180°]
    
    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style C fill:#d97706,stroke:#f59e0b,color:#f8fafc
    style D fill:#1e293b,stroke:#475569,color:#f8fafc
    style E fill:#1e293b,stroke:#475569,color:#f8fafc

Convex Polygons

A polygon is convex if a straight line segment connecting any two internal points lies entirely within the polygon's interior. In a convex polygon, all internal vertex angles are less than or equal to ( radians).

When a convex polygon is clipped against a convex rectangular window, the resulting clipped shape is guaranteed to remain a single, continuous convex polygon. This topological stability simplifies vertex management in rendering pipelines.

Concave Polygons

A polygon is concave if it contains at least one interior reflex angle strictly greater than . A line segment connecting two internal points in a concave polygon can cross outside its boundary.

Clipping a concave polygon against a rectangular window can split a single input shape into multiple disconnected sub-polygons. Standard pipeline clipping algorithms (such as Sutherland–Hodgman) can introduce extraneous connecting lines when processing concave shapes, requiring specialized algorithms (such as Weiler–Atherton) to separate the disconnected pieces properly.

Geometric Cases in Polygon Boundary Evaluation

Evaluating a polygon against a rectangular clipping window yields three spatial visibility states:

Completely Inside Polygons

A polygon is completely inside if every vertex satisfies and . The algorithm retains the vertex array unmodified, passing it directly to the rasterization pipeline.

Completely Outside Polygons

A polygon is completely outside if it lies entirely beyond one of the window's bounding lines. The clipping engine discards the entire vertex array, producing an empty vertex list and skipping rasterization.

Partially Inside Polygons

A polygon is partially inside if its boundary edges cross one or more window borders. The clipping engine processes each edge in sequence, calculating intersection coordinates and adding new boundary vertices to assemble a modified vertex loop.

Analytical Polygon Clipping Process

The general polygon clipping process transforms an input vertex array into an output vertex array through three steps:

Edge Collection Processing: The algorithm extracts ordered vertex pairs representing directed polygon edges around the perimeter.
Intersection Computation: For each edge crossing a window boundary, the algorithm solves linear equations to locate boundary intersection points.
Loop Reconstruction: The algorithm adds retained vertices and computed intersection points to an output array in traversal order, forming a closed spatial loop.

Engineering Applications of Polygon Clipping

Polygon clipping is essential in graphic rendering applications:

Cartographic Map Rendering: GIS engines clip complex landmass polygons against display window boundaries, enabling seamless map zooming and panning without leaking fill colors across map borders.
CAD Solid Modeling Layouts: CAD software uses polygon clipping to generate cross-sectional views of mechanical parts, truncating 3D solid meshes against 2D clipping planes.
Computer Graphics Shading Pipelines: Rasterization hardware clips 3D surface triangles against the viewing frustum before executing pixel fragment shaders, preventing off-screen geometry from wasting shading calculations.

3.6 Sutherland–Hodgman Polygon Clipping Algorithm

The Sutherland–Hodgman algorithm is the standard method for clipping convex polygons against rectangular windows in computer graphics. It replaces complex 2D spatial clipping with a sequence of four 1D boundary clipping passes, making it efficient and straightforward to implement.

Foundations of the Sutherland–Hodgman Pipeline

The Sutherland–Hodgman algorithm processes a polygon using a divide-and-conquer strategy.

Purpose and Characteristics

The primary goal of the Sutherland–Hodgman algorithm is to clip an arbitrary polygon against a convex clipping boundary. Rather than evaluating all four window boundaries simultaneously, the algorithm clips the entire polygon against one window boundary at a time. The vertex array produced by one boundary pass serves as the input array for the next.

The Divide-and-Conquer Clipping Strategy

A standard two-dimensional rectangular clipping window consists of four independent lines: Left, Right, Bottom, and Top. The algorithm breaks the 2D clipping problem down into four sequential 1D clipping stages.

graph LR
    A[Input Polygon Vertices] --> B[Left Boundary Clip]
    B --> C[Right Boundary Clip]
    C --> D[Bottom Boundary Clip]
    D --> E[Top Boundary Clip]
    E --> F[Final Clipped Polygon]

    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#475569,color:#f8fafc
    style C fill:#334155,stroke:#475569,color:#f8fafc
    style D fill:#334155,stroke:#475569,color:#f8fafc
    style E fill:#334155,stroke:#475569,color:#f8fafc
    style F fill:#0f766e,stroke:#14b8a6,color:#f8fafc

Sequential Boundary Pipeline Processing

The algorithm processes the polygon through four distinct pipeline stages:

Stage 1 (Left Boundary Pass): Clips the initial vertex list against the infinite line , generating intermediate vertex list .
Stage 2 (Right Boundary Pass): Clips list against the infinite line , generating intermediate vertex list .
Stage 3 (Bottom Boundary Pass): Clips list against the infinite line , generating intermediate vertex list .
Stage 4 (Top Boundary Pass): Clips list against the infinite line , generating the final output vertex list .

The Four Vertex Transition Cases

During any single boundary clipping pass, the algorithm evaluates directed edges formed by adjacent vertices. Depending on whether and lie inside or outside the current boundary line, the algorithm applies one of four vertex output rules.

graph TD
    A[Evaluate Edge V1 -> V2] --> B{Vertex Positions}
    B -->|Inside to Inside| C[Case 1: Output V2]
    B -->|Inside to Outside| D[Case 2: Output Intersection I]
    B -->|Outside to Inside| E[Case 3: Output Intersection I & V2]
    B -->|Outside to Outside| F[Case 4: Output Nothing]

    style A fill:#1e293b,stroke:#475569,color:#f8fafc
    style B fill:#334155,stroke:#64748b,color:#f8fafc
    style C fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style D fill:#d97706,stroke:#f59e0b,color:#f8fafc
    style E fill:#0f766e,stroke:#14b8a6,color:#f8fafc
    style F fill:#7f1d1d,stroke:#ef4444,color:#f8fafc

Overview of Vertex Transitions

Processing an edge against a boundary line produces four transition cases:

Inside Inside: Both vertices lie on the visible side of the boundary.
Inside Outside: Edge exits the visible region across the boundary line.
Outside Inside: Edge enters the visible region across the boundary line.
Outside Outside: Both vertices lie on the non-visible side of the boundary line.

Case 1: Inside to Inside Transition

If starting vertex is inside and ending vertex is inside:

Both vertices lie within the visible region.
The algorithm outputs ending vertex .

Case 2: Inside to Outside Transition

If starting vertex is inside and ending vertex is outside:

The edge crosses the boundary, exiting the visible region.
The algorithm calculates the boundary intersection point .
The algorithm outputs intersection point .

Case 3: Outside to Inside Transition

If starting vertex is outside and ending vertex is inside:

The edge crosses the boundary, entering the visible region.
The algorithm calculates the boundary intersection point .
The algorithm outputs both intersection point and ending vertex .

Case 4: Outside to Outside Transition

If starting vertex is outside and ending vertex is outside:

Both vertices lie entirely outside the visible region.
The algorithm outputs nothing.

Algorithmic Steps and Implementation

Executing the Sutherland–Hodgman algorithm follows a simple iterative procedure:

Initialize Boundary List: Select the initial clipping boundary (Left, Right, Bottom, or Top).
Fetch Vertices: Load the input vertex array .
Traverse Edges: For to , form directed edge (where to close the loop).
Apply Transition Rules: Evaluate against the active boundary and append generated vertices to the current output array based on Cases 1–4.
Pass to Next Stage: Send the generated vertex array as the input to the next boundary stage.
Repeat: Repeat steps 2–5 for all four window boundaries.

Performance Advantages and Topological Limitations

Evaluating Sutherland–Hodgman reveals its operational strengths and geometric limits.

Algorithmic Strengths

Linear Time Complexity: The algorithm runs in time, where is the number of polygon vertices.
Pipeline Suitability: The sequential structure matches graphics hardware architectures well, allowing vertex data to stream through memory buffers efficiently.
Clean Output for Convex Shapes: When clipping convex polygons against convex windows, the algorithm produces correctly structured convex polygons every time.

Topological Limitations

When clipping concave polygons, the algorithm can produce degenerate connecting lines that run along window borders. These extra lines connect separate visible parts of the clipped shape into a single output loop, which can cause rendering artifacts during solid filling. Concave polygon clipping often requires more specialized approaches, such as the Weiler–Atherton algorithm.

Step-by-Step Numerical Demonstrations

The following worked numerical problems demonstrate Sutherland–Hodgman polygon clipping step by step.

Worked Numerical Problem 1: Convex Triangle Clipping Against 4 Boundaries

Problem Statement: A rectangular window is defined by bounds . A triangle has vertices . Trace the Sutherland–Hodgman pipeline through all four boundary clipping passes and list the output vertices at each stage.

       Y
       ^
    80 |            V2(50,80)
       |           /|
    60 |+---------+ |  <- Top Boundary (y=60)
       || Window  | |
       || (10,60) | |
    32 |I1        | |
    20 |I2-------V3(50,20)
    10 |+---------+    <- Bottom Boundary (y=10)
     0 +------------------> X
       0  10     40 50
          ^       ^
       Left(10)  Right(40)

Initial Input Vertex List:

Pass 1: Clip against Left Boundary ().

Edge :
- (Outside); (Inside) Case 3 (Outside Inside).
- Calculate intersection along :
- Output: and .
Edge :
- (Inside); (Inside) Case 1 (Inside Inside).
- Output: .
Edge :
- (Inside); (Outside) Case 2 (Inside Outside).
- Calculate intersection along :
- Output: .

Vertex List after Left Pass:

Pass 2: Clip against Right Boundary ().

Edge :
- (Inside); (Outside) Case 2 (Inside Outside).
- Calculate intersection along :
- Output: .
Edge :
- (Outside); (Outside) Case 4 (Outside Outside).
- Output: Nothing.
Edge :
- (Outside); (Inside) Case 3 (Outside Inside).
- Calculate intersection along :
- Output: and .
Edge :
- (Inside); (Inside) Case 1 (Inside Inside).
- Output: .

Vertex List after Right Pass:

Pass 3: Clip against Bottom Boundary ().

All Y-coordinates in () are . Every vertex lies inside the bottom boundary, so all edges fall under Case 1 (Inside Inside).

Vertex List after Bottom Pass:

Pass 4: Clip against Top Boundary ().

Edge :
- (Outside); (Inside) Case 3 (Outside Inside).
- Vertical line along Intersection .
- Output: and .
Edge :
- (Inside); (Inside) Case 1 (Inside Inside).
- Output: .
Edge :
- (Inside); (Inside) Case 1 (Inside Inside).
- Output: .
Edge :
- (Inside); (Outside) Case 2 (Inside Outside).
- Calculate intersection along :
- Output: .

Final Clipped Polygon Vertices:

The clipped shape is a 5-sided polygon contained entirely within the window boundaries.

Worked Numerical Problem 2: Partially Visible Quad Clipping With Multiple Intersections

Problem Statement: Clip a rectangle against a smaller clipping window . Trace the vertex transformations across the four boundary clipping passes.

Initial Input Vertex List:

Pass 1: Clip against Left Boundary ().

Edge : Outside Inside Output and .
Edge : Inside Inside Output .
Edge : Inside Outside Output .
Edge : Outside Outside Output Nothing.

Pass 2: Clip against Right Boundary ().

Edge : Inside Outside Output .
Edge : Outside Outside Output Nothing.
Edge : Outside Inside Output and .
Edge : Inside Inside Output .

Pass 3: Clip against Bottom Boundary ().

Edge : Outside Inside Output and .
Edge : Inside Inside Output .
Edge : Inside Outside Output .
Edge : Outside Outside Output Nothing.

Pass 4: Clip against Top Boundary ().

Edge : Inside Outside Output .
Edge : Outside Outside Output Nothing.
Edge : Outside Inside Output and .
Edge : Inside Inside Output .

Final Result: The algorithm clips the larger rectangle down to match the window boundaries exactly, producing a square with vertices , , , and .

3.7 Comparison of Line and Polygon Clipping

Line clipping and polygon clipping address different requirements within the rendering pipeline. Comparing their underlying operations, data structures, computational complexity, and applications highlights these differences.

Structural Analysis of Line Segment Clipping

Line segment clipping operates on independent vector primitives defined by pairs of endpoints. The output is a collection of truncated line segments. Because each line is evaluated independently, the algorithm does not need to track relationships between adjacent primitives.

Structural Analysis of Area Polygon Clipping

Polygon clipping processes ordered, closed vertex arrays that define filled 2D regions. The output is an updated list of ordered vertices. The clipping algorithm must insert intermediate boundary vertices to keep the polygon closed, ensuring that area-filling and shading algorithms work correctly.

Comparative Synthesis of Clipping Methods

The structural, algorithmic, and computational differences between line and polygon clipping are summarized below:

Structural Attribute	Line Clipping (Cohen–Sutherland)	Polygon Clipping (Sutherland–Hodgman)
Input Data Primitive	Independent line segment	Ordered vertex array
Output Data Primitive	Truncated line segment or discarded primitive	Modified closed polygon vertex loop
Boundary Topology	Open linear stroke segment	Closed filled planar surface region
Vertex Insertion Logic	Replaces original endpoints with intersections	Appends new boundary vertices to loop
Core Data Structure	4-bit region outcodes ()	Sequential array or linked list of vertices
Algorithmic Strategy	Fast bitwise testing + line-edge algebra	Sequential pass through 4 boundary stages
Topological Constraints	None (Processes any straight line)	Works best on convex polygons
Primary Applications	Wireframe CAD views, vector drawings, GIS roads	Solid area rasterization, 3D mesh rendering

Chapter Conclusion

Geometric clipping is essential for managing spatial boundaries in computer graphics systems. It bridges continuous world coordinate models and physical display devices, filtering out non-visible primitives before rasterization. This optimizes rendering performance and prevents frame buffer access errors.

A solid understanding of clipping relies on the window-to-viewport transformation, which maps world coordinates into device space while preserving spatial relationships. For vector primitives, the Cohen–Sutherland algorithm uses 4-bit outcodes and bitwise logic to quickly reject off-screen lines, reserving floating-point intersection calculations for visible line segments.

For solid surfaces, the Sutherland–Hodgman algorithm uses a pipeline approach to clip polygons against window boundaries sequentially. By applying four vertex transition rules, it generates closed vertex loops that maintain correct solid fills during rasterization.

Common Student Misconceptions

Confusing Windows and Viewports: A window defines what portion of a scene is selected in world coordinates, while a viewport defines where and at what scale that content appears on screen. Changing the window size alters the visible scene content; changing the viewport size scales the displayed image on screen.
Assuming Bitwise AND Identifies All Invisible Lines: A bitwise AND result of 0000 does not guarantee a line is visible. It simply means the line cannot be trivially rejected. The segment may still lie entirely outside the window across a corner region, requiring intersection calculations to confirm visibility.
Applying Line Clipping to Solid Polygons: Trimming polygon edges using line clipping produces disconnected line segments rather than closed shapes. Without inserted boundary vertices, solid filling algorithms leak colors across display edges.
Assuming Sutherland–Hodgman Handles All Concave Polygons Perfectly: Sutherland–Hodgman can insert extra degenerate lines along window borders when clipping concave polygons. Separating these into distinct polygons requires algorithms like Weiler–Atherton.

Self-Test Questions

Conceptual Analysis: Explain the difference between a world coordinate clipping window and a device coordinate viewport. Derive the horizontal scaling factor and vertical scaling factor equations, explaining how aspect ratio mismatches distort rendered images.
Mathematical Transformation: A world window is defined by . The display viewport is defined by . Map the world point to its corresponding viewport coordinates using matrix multiplication.
Outcode Logic Execution: Given a clipping window with limits , determine the 4-bit outcodes for points , , , and . Evaluate line segments and using bitwise OR and AND tests, classifying their visibility states.
Algorithmic Line Tracing: Apply the Cohen–Sutherland algorithm to clip a line segment with endpoints and against a window defined by . Show all intermediate outcode updates, set bit checks, slope calculations, and final clipped endpoints.
Polygon Pipeline Tracing: A triangle has vertices . Clip this polygon against a rectangular window defined by using the Sutherland–Hodgman algorithm. Trace the vertex array output at each stage of the four boundary clipping passes (Left, Right, Bottom, Top).

Chapter 3 : Clipping

Chapter 3 : Clipping