Unit 1: Introduction [6 Hours]

This unit lays the foundation of Computer Graphics: why it matters, what hardware draws an image to your screen, and the core algorithms that turn mathematical shapes (lines, circles, ellipses) into actual pixels. The scan conversion and clipping algorithms here are the most exam-heavy part of this unit and of the subject as a whole, expect numerical, step-by-step questions on Bresenham's Line, Midpoint Circle, and Cohen-Sutherland clipping in particular.

Tested Topics

• DDA line drawing algorithm — 2× (2023, 2022)
• Flood fill algorithm — 2× (2024, 2022)
• Midpoint circle drawing algorithm — 2× (2024, 2022)
• Beam penetration vs Shadow mask methods — 1× (2023)
• Boundary fill vs Flood fill algorithms (differentiation) — 1× (2023)
• Bresenham's line drawing algorithm (decision parameter) — 1× (2024)
• Computer Graphics vs Image Processing — 1× (2023)
• Horizontal/vertical retrace of electron beam — 1× (2022)
• Pixel and resolution — 1× (2024)
• Random scan display system architecture — 1× (2022)
• Raster scan display system (working) — 1× (2023)
• Raster scan vs Vector scan display — 1× (2024)
• Scan conversion (definition) — 1× (2024)
• Video controller in raster scan system — 1× (2024)

1.1 Advantage of Computer Graphics and Areas of Application

Core Definition

Computer Graphics is the field of computer science concerned with generating, manipulating, and displaying images and visual data using a computer.

Computer graphics is simply how a computer turns numbers and instructions into pictures you can see on a screen.

Detailed Explanation

Computer graphics matters because humans process visual information far faster than raw text or numbers. A chart explains a trend instantly; a thousand rows of numbers do not. This is why graphics is used everywhere modern computing touches: design, entertainment, science, and communication.

Advantages

Better understanding → visual data (charts, diagrams, 3D models) is grasped faster than raw numbers.
Improved communication → designs, simulations, and presentations communicate ideas without language barriers.
Realistic simulation → allows training and testing in safe, virtual environments (flight simulators, surgery practice).
Creative and entertainment value → enables movies, games, and animation that would be impossible or extremely costly to film physically.
Design efficiency → CAD tools let engineers test and modify designs digitally before physical production, saving cost and time.

Areas of Application

1.2 Hardware and Software for Computer Graphics

Core Definition

Graphics hardware refers to the physical devices, input, display, and hard copy, used to create and output images, while graphics software refers to the programs and packages used to generate and manipulate those images.

Hardware is the physical equipment (screen, printer, mouse); software is the program that decides what gets drawn and how.

Detailed Explanation

Every graphics system needs three categories of hardware working together: devices to input commands or drawings (mouse, scanner, digitizer), a device to display the result temporarily (a monitor), and devices to produce a permanent, hard copy output (printers, plotters). Software then sits on top, ranging from low-level graphics libraries to full applications like CAD or paint programs.

Hard Copy Devices

Display Technologies

CRT (Cathode Ray Tube) → fires an electron beam at a phosphor-coated screen; the beam's position and intensity are controlled to light up phosphor dots, the basis for both random-scan and raster-scan displays covered next.
LCD (Liquid Crystal Display) → uses liquid crystals that twist to block or pass light from a backlight, controlled per pixel; thinner and more power-efficient than CRT.
Plasma and LED displays [verify] → use charged gas (plasma) or light-emitting diodes (LED) directly as the light source per pixel, offering high brightness and contrast.

Graphics Software Categories

General programming packages → provide graphics functions as a library (e.g., OpenGL) that a programmer calls from a language like C++.
Special-purpose application packages → ready-made software for specific tasks: CAD tools, paint programs, animation software, where the user does not write code, just uses the interface.

1.3 Random Scan Display System, Video Controller, Random Scan Display Processor

Core Definition

A random scan display system (vector display) draws an image by directing the electron beam only along the actual line paths that make up the picture, rather than scanning the entire screen, and a random scan display processor is the dedicated hardware that repeatedly feeds those line-drawing commands to the beam to keep the image refreshed.

Instead of "painting" the whole screen row by row, a random scan display draws an image the way you would draw with a pen: it moves directly from point to point only where a line actually exists.

Detailed Explanation

In a random scan (vector) system, the picture is stored as a set of line-drawing commands, often called a display file or refresh display file, listing the endpoints of every line segment in the image. The display processor cycles through this file and steers the electron beam directly between those endpoints, lighting the phosphor only along actual line paths. Because curved or complex shapes still need to be turned into many short straight line segments, random scan systems are best suited to line drawings such as engineering schematics, rather than realistic, shaded images.

Video Controller

A video controller is the hardware component that manages how an image is continuously sent from memory to the display, refreshing the screen many times per second so the picture appears stable instead of flickering. It works by repeatedly cycling through the stored picture information (line commands in a random scan system, or pixel values in a raster system, covered in 1.4) and converting that information into the deflection or intensity signals the screen hardware needs at every refresh cycle.

Random Scan Display Processor (Architecture)

The random scan display processor sits between the CPU and the CRT, and operates in a repeating cycle:

Step 1 → The CPU sends drawing commands (e.g., "draw line from A to B") to the display processor.
Step 2 → The display processor stores these commands in the refresh display file in memory.
Step 3 → The processor continuously reads through the display file, command by command, converting each into the analog deflection voltages needed to move the electron beam.
Step 4 → The beam is moved directly from one line's start point to its end point, lighting the phosphor only along that path.
Step 5 → Once the entire display file has been processed, the cycle repeats from the top, refreshing the whole image roughly 30 to 60 times per second so it appears continuously visible to the human eye.

1.4 Raster Graphics

Core Definition

Raster graphics (raster scan) is a display technique where the electron beam sweeps across the entire screen row by row, lighting up individual pixels based on values stored in a frame buffer, building the full image like a grid rather than a set of lines.

Instead of drawing only the lines, a raster display lights up every single dot on the screen, row after row, deciding for each dot whether it should be on, off, or a certain color, based on data stored in memory.

Detailed Explanation

A raster scan display stores the entire image as a grid of pixel values in a memory area called the frame buffer (or refresh buffer). The video controller reads this frame buffer row by row, left to right, top to bottom, and converts each pixel's stored value into the correct intensity or color signal for the screen, repeating roughly 60 times a second. Because every pixel on the screen is touched on every refresh, raster systems can represent filled areas, shading, and photographic detail far better than random scan systems, which is why nearly all modern displays (LCD, LED) use raster-based principles.

Key Concepts

Pixel → the smallest controllable point of an image, each holding a color/intensity value.
Frame buffer → the memory area storing the color value of every pixel on the screen for the current frame.
Resolution → the number of pixels in the horizontal and vertical directions (e.g. 1920×1080); higher resolution means finer detail.
Refresh rate → how many times per second the entire frame buffer is redrawn to the screen, measured in Hz.
Interlaced scanning → refreshes odd-numbered scan lines first, then even-numbered lines, in alternate passes, reducing the data rate needed per pass at the cost of potential flicker.
Non-interlaced (progressive) scanning → refreshes every line in a single top-to-bottom pass, giving a steadier image.

Raster Scan vs Random Scan

1.5 Scan Conversion Algorithms (Line, Circle, Ellipse)

Core Definition

Scan conversion is the process of converting a mathematically defined shape, like a line, circle, or ellipse, into the discrete set of pixel positions on a raster grid that best approximate that shape.

A line or circle drawn on paper is a smooth, continuous curve, but a screen only has discrete dots. Scan conversion algorithms decide exactly which dots to light up so the result looks like that smooth shape.

Detailed Explanation

Because a pixel grid has no true diagonal or curved lines, any non-horizontal/vertical line or curve must be approximated using the nearest pixels at each step. The challenge solved by these algorithms is doing this approximation accurately and fast, using only integer arithmetic where possible, since floating-point operations are slower for hardware to compute repeatedly.

DDA (Digital Differential Analyzer) Line Algorithm

The DDA algorithm draws a line by calculating successive points using the line's slope, incrementing one coordinate by 1 and computing the other using floating-point addition.

Step 1 → Compute dx = x1 - x0 and dy = y1 - y0.
Step 2 → Let steps = max(|dx|, |dy|) (the larger of the two determines how many points to plot).
Step 3 → Compute increments xinc = dx / steps and yinc = dy / steps.
Step 4 → Starting at (x0, y0), repeatedly add xinc to x and yinc to y, rounding each to the nearest integer to plot the pixel, for steps iterations.

DDA is simple to understand but uses floating-point addition and rounding at every single step, which makes it slower than Bresenham's algorithm below; it is mainly taught as a stepping stone toward understanding the more efficient integer-only approach.

Bresenham's Line Algorithm

Bresenham's algorithm draws a line using only integer arithmetic, by tracking a decision parameter that determines whether the next pixel should move straight or diagonally, avoiding rounding and division entirely. The version below assumes the line has a slope between 0 and 1, with x0 < x1 and y0 < y1 (the most commonly taught case).

Step 1 → Compute dx = x1 - x0, dy = y1 - y0.
Step 2 → Compute the initial decision parameter: p0 = 2dy - dx.
Step 3 → At each step, increment x by 1. If pk < 0, keep the same y, and the next parameter is pk+1 = pk + 2dy. If pk >= 0, increment y by 1 as well, and the next parameter is pk+1 = pk + 2dy - 2dx.
Step 4 → Repeat Step 3 until x reaches x1.

The decision parameter is a clever shortcut: it represents (scaled and shifted) which of the two candidate pixels, directly across or diagonally across, lies closer to the true mathematical line, all without ever computing a square root or a fraction.

Worked Example: Line from (20,10) to (30,18)

dx = 10, dy = 8. p0 = 2(8) - 10 = 6. Constants used at each step: add 2dy = 16 when p < 0, or add 2dy - 2dx = -4 when p >= 0.

The line correctly ends at (30,18), matching the given endpoint, confirming the algorithm worked correctly.

Midpoint Circle Algorithm

The midpoint circle algorithm plots a circle using its 8-way symmetry: it only calculates points for one octant (45 degrees of the circle, typically from the top point to the 45° diagonal), then mirrors those points into the other 7 octants, since a circle is symmetric across both axes and both diagonals.

Step 1 → Start at (x0, y0) = (0, r), the topmost point of the circle.
Step 2 → Compute the initial decision parameter: p0 = 1.25 - r (often rounded to 1 - r for integer radii).
Step 3 → At each step, always increment x by 1. If pk < 0, keep the same y, and the next point's parameter is pk+1 = pk + 2xk+1 + 1. If pk >= 0, also decrement y by 1, and the next parameter is pk+1 = pk + 2xk+1 + 1 - 2yk+1.
Step 4 → Stop once x equals y (the 45° boundary); for each calculated (x,y), plot all 8 symmetric points: (±x,±y) and (±y,±x).

Worked Example: Circle with r = 10

p0 = 1 - 10 = -9, start (0,10).

The algorithm stops at (7,7) since x = y here, the 45° boundary. Each point listed is then mirrored into all 8 octants to complete the full circle.

Midpoint Ellipse Algorithm

An ellipse only has symmetry across its two axes (4-way, not 8-way), and its curvature changes differently along its width versus its height, so the algorithm splits the curve into two regions at the point where the slope equals -1.

Region 1 (near the top of the ellipse, where the boundary slope is shallower than -1, x changes faster): step x by 1 each time, decide whether y also decreases.
Region 2 (near the side of the ellipse, where the boundary is steeper than -1, y changes faster): step y by -1 each time, decide whether x also increases.

For an ellipse with semi-axes rx and ry centered at the origin:

Region 1 initial parameter: p1_0 = ry² - rx²·ry + 0.25·rx².
While in Region 1: if p1k < 0, move to (xk+1, yk) with p1k+1 = p1k + 2ry²·xk+1 + ry²; otherwise move to (xk+1, yk-1) with p1k+1 = p1k + 2ry²·xk+1 - 2rx²·yk+1 + ry². Switch to Region 2 once the slope becomes steeper than -1.

Region 2 initial parameter: p2_0 = ry²·(x0+0.5)² + rx²·(y0-1)² - rx²·ry², using the last point from Region 1.
While in Region 2: if p2k > 0, move to (xk, yk-1) with p2k+1 = p2k - 2rx²·yk+1 + rx²; otherwise move to (xk+1, yk-1) with p2k+1 = p2k + 2ry²·xk+1 - 2rx²·yk+1 + rx². Stop when y = 0.

As with the circle, every calculated point is mirrored into the other 3 quadrants, since an ellipse is symmetric across both its major and minor axes.

1.6 Area Filling Algorithms (Rectangle, Ellipse)

Core Definition

Area filling is the process of coloring all the pixels that lie inside a closed boundary, such as a rectangle or an ellipse, rather than just drawing the outline.

If scan conversion draws the outline of a shape, area filling is what colors in everything inside that outline, like coloring inside the lines of a drawing.

Detailed Explanation

The general strategy for filling any shape is scan-line filling: for every horizontal row (scan line) that intersects the shape, find where the shape's boundary crosses that row, and color every pixel between those crossing points. The exact way you find those crossing points depends on the shape.

Filling a Rectangle

A rectangle is the simplest case because its boundary is always made of horizontal and vertical lines, so the left and right boundary on every scan line are simply the rectangle's fixed xmin and xmax.

for (y = ymin; y <= ymax; y++)
{
    for (x = xmin; x <= xmax; x++)
    {
        SetPixel(x, y);
    }
}

This nested loop simply colors every pixel between the rectangle's corners, row by row.

Filling an Ellipse

An ellipse cannot use fixed left/right boundaries because its width changes at every row. The fill uses the same midpoint ellipse boundary points calculated in Section 1.5: for each computed boundary point (x, y), the pixels to fill on that scan line run from -x+x at height y (and mirrored for -y).

// For each (x, y) boundary point computed by the midpoint ellipse algorithm:
for (px = -x; px <= x; px++)
{
    SetPixel(centerX + px, centerY + y);   // fill upper half row
    SetPixel(centerX + px, centerY - y);   // fill mirrored lower half row
}

This reuses the boundary-tracing work already done for drawing the ellipse outline, instead of recalculating intersections from scratch, making filling and outlining closely connected steps.

1.7 Clipping: Line Clipping (Cohen-Sutherland Algorithm)

Core Definition

Clipping is the process of determining which portion of a drawing lies inside a defined rectangular clipping window, and discarding or trimming everything outside it. The Cohen-Sutherland algorithm performs line clipping efficiently using a 4-bit region code assigned to each endpoint.

Clipping is like cutting a photo down to fit a picture frame, anything outside the frame's edges gets cut away, and anything crossing an edge gets trimmed exactly at that edge.

Detailed Explanation

Checking every line against every edge with full intersection math is wasteful when most lines are either entirely inside or entirely outside the window. Cohen-Sutherland speeds this up by first assigning each endpoint a 4-bit outcode describing which side(s) of the window it lies outside, allowing instant accept/reject decisions for most lines without any intersection calculation at all.

Region Codes (Outcodes)

The clipping window has four edges: xmin, xmax, ymin, ymax. Each endpoint gets a 4-bit code, ordered Top, Bottom, Right, Left:

Top bit = 1 if y > ymax.
Bottom bit = 1 if y < ymin.
Right bit = 1 if x > xmax.
Left bit = 1 if x < xmin.
A point fully inside the window gets the code 0000.

Algorithm Steps

Step 1 → Compute the outcode for both endpoints of the line.
Step 2 → Trivial accept: if both outcodes are 0000, the entire line is inside, keep it unchanged.
Step 3 → Trivial reject: if the bitwise AND of both outcodes is not 0000, both points lie outside the same edge, the entire line is outside, discard it.
Step 4 → Otherwise, the line needs clipping: pick the endpoint with a non-zero outcode, find which boundary it violates, and compute the exact intersection point of the line with that boundary using the line's parametric equation.
Step 5 → Replace that endpoint with the intersection point, recompute its outcode, and repeat from Step 2 until the line is either trivially accepted or trivially rejected.

Worked Example

Clipping window: xmin=10, ymin=10, xmax=50, ymax=50. Line from P1=(5,40) to P2=(60,20).

Outcode of P1: x=5 < 10 → Left bit set → 0001. Outcode of P2: x=60 > 50 → Right bit set → 0010. AND of codes = 0000, so not a trivial reject; neither is 0000, so not a trivial accept either, meaning the line must actually be clipped.

P1 violates the Left edge (x=10). Using the parametric line equation with dx=55, dy=-20: t = (10-5)/55 ≈ 0.0909, giving y = 40 + 0.0909×(-20) ≈ 38.18. New point: P1' = (10, 38.18), outcode now 0000.

P2 still violates the Right edge (x=50). Recomputing from P1' to P2 with dx=50, dy=-18.18: t = (50-10)/50 = 0.8, giving y = 38.18 + 0.8×(-18.18) ≈ 23.64. New point: P2' = (50, 23.64), outcode now 0000.

Both codes are now 0000 → trivial accept. The clipped line runs from (10, 38.18) to (50, 23.64).

1.8 Clipping: Circle and Ellipse Clipping

Core Definition

Circle and ellipse clipping determines which portion of a curved boundary lies inside a rectangular clipping window, trimming the curve at the points where it crosses the window's edges.

Just like a line can be cut where it crosses the frame's edge, a circle or ellipse is cut at the points where its round boundary crosses each edge of the clipping window, keeping only the arc that lies inside.

Detailed Explanation

Unlike a line, a circle or ellipse has no single straight intersection formula, since its boundary is curved, but the same accept/reject logic from line clipping still helps reduce unnecessary work before any curve math is done.

Clipping Procedure

Step 1 → Bounding box test: compute the circle or ellipse's bounding rectangle. If this bounding rectangle is entirely inside the clipping window, trivially accept the entire shape with no further computation. If the bounding rectangle is entirely outside the window on one side, trivially reject the entire shape.
Step 2 → If the bounding box partially overlaps the window, find the points where the circle/ellipse boundary equation intersects each of the window's four edge lines, by substituting the edge's fixed x (for vertical edges) or fixed y (for horizontal edges) into the curve's equation and solving for the other coordinate.
Step 3 → Walk along the curve's boundary (using the same scan-conversion points from Section 1.5) and keep only the arc segments whose points satisfy all four window boundary conditions (xmin ≤ x ≤ xmax and ymin ≤ y ≤ ymax) simultaneously.
Step 4 → Discard the arc segments lying outside any of the four edges.

1.9 Clipping Polygons (Sutherland-Hodgman Algorithm)

Core Definition

The Sutherland-Hodgman algorithm clips a polygon against a rectangular window by processing the polygon against one window edge at a time, producing a new, smaller polygon after each edge, until all four edges have been applied.

Instead of trying to clip a polygon against all four window edges at once, this algorithm clips against one edge fully first, then feeds that result into clipping against the next edge, like passing dough through four shaping rollers, one side at a time.

Detailed Explanation

A polygon is just a sequence of connected vertices. For each single clipping edge, the algorithm walks through the polygon's vertices in order, comparing each vertex against the previous one, and decides what to keep based on whether each vertex is inside or outside that one edge.

Algorithm Steps (per edge)

For each pair of consecutive vertices S (previous) and P (current), tested against one clipping edge:

Case 1 → If P is inside and S is inside: add P to the output polygon.
Case 2 → If P is inside and S is outside: the edge SP crosses the boundary, so first add the intersection point of SP with the clip edge, then add P.
Case 3 → If P is outside and S is inside: the edge SP crosses the boundary going out, so add only the intersection point of SP with the clip edge (P itself is discarded).
Case 4 → If P is outside and S is outside: add nothing.

This process runs for every vertex pair around the polygon, against the left edge first, then the result is run again against the right edge, then the bottom edge, then the top edge, with the output of each stage becoming the input polygon for the next stage.

Illustrative Example (Single Edge)

Consider clipping a triangle with vertices S=(5,5) (outside, left of xmin=10) and P=(20,5) (inside) against the left edge x=10. This matches Case 2: P is inside, S is outside. The intersection of segment SP with x=10 is computed (here, simply (10,5) since both points share y=5), so the output adds (10,5) first, then (20,5). This same Case 1–4 logic is then repeated for every other vertex pair of the polygon, and then for the remaining three edges in turn, until a fully clipped polygon remains.