Computer Graphics Essentials: Algorithms, Rendering, and Display

Posted on Aug 23, 2025 in Computers

Raster vs. Vector Graphics: Key Differences and Preferences

This section outlines the fundamental distinctions between raster and vector graphics methods and discusses their respective applications.

Raster Graphics

• Representation: Pixels
• Resolution: Resolution-dependent
• File Size: Larger (especially for high-resolution images)
• Scaling: Blurs or pixelates on scaling
• Common Formats: JPG, PNG, BMP

Vector Graphics

• Representation: Mathematical formulas (lines, curves)
• Resolution: Resolution-independent
• File Size: Smaller
• Scaling: Scales cleanly without loss of quality
• Common Formats: SVG, EPS

Preference: If working with photos or detailed images, raster graphics are generally better. If designing logos, icons, or anything that needs to scale (e.g., for both mobile and billboards), vector graphics are superior. Overall, I prefer vector graphics for most design purposes because they are scalable, lightweight, and easy to edit.

Image Space vs. Object Space for Visible Surface Detection

Differentiating between image space and object space methods for visible surface determination is crucial in computer graphics.

Image Space Methods

• Working Level: Pixel level
• Comparison: Compares depth (z-values) at each pixel
• Performance: Slower for complex scenes (due to per-pixel checks)
• Common Algorithms: Z-buffer, A-buffer
• Accuracy: High accuracy (pixel-level precision)
• Implementation: Easier to implement

Object Space Methods

• Working Level: Object or surface level
• Comparison: Compares geometry (e.g., which object hides another)
• Performance: Faster for fewer objects, but involves more complex logic
• Common Algorithms: Back-face culling, Depth sorting, BSP Tree
• Accuracy: May miss small overlaps unless subdivided
• Implementation: More complex algorithms

Cohen-Sutherland Line Clipping Algorithm Explained

The Cohen-Sutherland Line Clipping Algorithm is a popular method used in computer graphics to clip a line segment to a rectangular clipping window.

Algorithm Steps:

1. Assign Outcodes: Assign a 4-bit region code (outcode) to both endpoints of the line. Each bit indicates if the point is above, below, right, or left of the clipping window.
2. Check for Trivial Acceptance/Rejection:
   • If both outcodes are 0000: The line is completely inside the window → Accept.
   • If the bitwise AND of both outcodes is not 0000: The line is completely outside → Reject.
   • Otherwise: The line is partially inside → Proceed to Clip.
3. Clip the Line: If the line is partially inside, clip it against one boundary at a time (using intersection formulas).
4. Update and Repeat: Update the outcode of the clipped point and repeat steps 2 and 3 until the line segment is either accepted or rejected.

Factors for Choosing Visible Surface Detection Algorithms

When selecting a Visible Surface Detection Algorithm (also known as Hidden Surface Removal), several factors must be carefully considered:

1. Scene Complexity:
   • Number of Objects/Polygons: Algorithms must handle large scenes efficiently.
   • Intersecting and Overlapping Objects: Requires accurate visibility handling.
2. Object Types:
   • Opaque vs. Transparent Objects: Some algorithms (e.g., Z-buffer) work well with opaque objects but struggle with transparency unless modified.
3. Rendering Speed and Performance:
   • Real-time vs. Offline Rendering: Real-time applications (games, VR) demand fast algorithms like the Z-buffer.
4. Hardware Support:
   • Some algorithms (like the Z-buffer) are hardware-accelerated by GPUs, significantly improving performance.
5. Memory Requirements:
   • Algorithms such as the Z-buffer and A-buffer require additional memory for depth or coverage information.
6. Depth Precision:
   • Depth buffer algorithms can suffer from ‘z-fighting’ if precision is too low.
7. Sorting Requirements:
   • Algorithms like the Painter’s Algorithm necessitate sorting of surfaces by depth.
8. Transparency and Special Effects:
   • Transparency handling requires algorithms that support alpha blending (e.g., A-buffer).
9. Algorithm Complexity:
   • Time Complexity: Directly impacts performance, especially in real-time scenarios.
10. Type of Projection:
    • Some algorithms are designed for orthographic projection, while others perform better with perspective projection.

Understanding Light: Ambient, Diffuse, and Specular Reflection

These three terms describe different ways light interacts with surfaces in a scene, crucial for realistic rendering.

Ambient Light

Ambient light refers to the light present in a scene, typically originating from all directions. It is often diffused and scattered, creating a uniform illumination that lacks a specific source. This type of light usually results from natural or artificial light sources reflecting off various surfaces within an environment.

Diffuse Reflection

Diffuse reflection occurs when light strikes a rough or matte surface, causing the light to scatter in many directions. This interaction produces a soft, non-glossy reflection. In diffuse reflection, the angle of incidence (the angle at which light hits the surface) is generally not equal to the angle of reflection (the angle at which the light bounces off).

Specular Reflection

Specular reflection happens when light strikes a smooth, shiny surface, such as a mirror or still water. In this case, the light is reflected at a specific angle, which is equal to the angle of incidence. This phenomenon produces clear, sharp reflections, like the image of a person in a mirror.

Calculating Frame Buffer Size for Uncompressed Video

Let’s calculate the frame buffer size required to store a 640×480 black and white video of 5 minutes length without compression.

Given:

• Video Resolution: 640×480 pixels
• Video Length: 5 minutes
• Color Depth: Black and White (1 bit per pixel)
• Frame Rate: 30 frames per second (FPS) – Assumed standard

Step 1: Determine the Number of Pixels per Frame

Each frame has a resolution of 640×480, so the total number of pixels per frame is:

Pixels per frame = 640 × 480 = 307,200 pixels

Step 2: Determine the Bit Depth per Pixel

Since the video is black and white, each pixel can be represented by 1 bit (either black or white). Therefore, the bit depth per pixel is 1 bit.

Step 3: Calculate the Size of Each Frame

The size of each frame in bits is:

Size per frame = Pixels per frame × Bit depth per pixel = 307,200 × 1 bit = 307,200 bits

Now, let’s convert this to bytes (since 1 byte = 8 bits):

Size per frame in bytes = 307,200 / 8 = 38,400 bytes = 38.4 KB

Step 4: Determine the Total Number of Frames in the Video

The video length is 5 minutes, which is equivalent to 300 seconds. Assuming a standard video frame rate of 30 frames per second (FPS), the total number of frames is:

Total frames = 300 seconds × 30 FPS = 9,000 frames

Step 5: Calculate the Total Size of the Video

Finally, to find the total size of the video, we multiply the size of each frame by the total number of frames:

Total size = Size per frame × Total frames = 38.4 KB × 9,000 = 345,600 KB

Now, let’s convert this to megabytes (1 MB = 1,024 KB):

Total size in MB = 345,600 / 1,024 = 337.5 MB

Window vs. Viewport: Graphics Coordinate Systems

Understanding the distinction between a window and a viewport is fundamental in computer graphics for displaying objects correctly.

Window

• Definition: A rectangular area defined in world coordinates (user-defined space).
• Purpose: Specifies the part of the scene to be displayed.
• Coordinates: Uses world coordinates (real-world values like centimeters, meters, etc.).
• Size: Can be any size, depending on the scene.

Viewport

• Definition: A rectangular area defined in device coordinates (screen/pixel space).
• Purpose: Specifies where the selected part of the scene will appear on the output screen.
• Coordinates: Uses screen coordinates (pixels).
• Size: Depends on the display device’s resolution.

Why Mapping is Required

When creating graphics, objects are initially defined in world coordinates. However, to display them on a screen, we must convert these world coordinates to screen coordinates (pixels). This conversion is achieved through window-to-viewport transformation. Essentially, the window defines what you want to show (a portion of the world), and the viewport defines where you want to show it (on the screen). This mapping is essential to display world-defined graphics properly on pixel-based screens.

Raster Display Flickering: Pixel Access Rate Analysis

Let’s determine whether an access rate of 20 nanoseconds per pixel for a 640×480 raster screen will produce a flickering effect.

Given:

• Access time per pixel = 20 nanoseconds (20 × 10^-9 seconds)
• Screen resolution = 640 × 480 pixels = 307,200 pixels

Step 1: Calculate Total Time to Refresh One Frame

Total time = Number of pixels × Time per pixel
Total time = 307,200 × 20 × 10-9 seconds
Total time = 6,144,000 × 10-9 seconds
Total time = 0.006144 seconds = 6.144 milliseconds

Step 2: Calculate Possible Frame Rate

Frame rate = 1 / Time per frame
Frame rate = 1 / 0.006144 seconds ≈ 162.73 frames per second

Conclusion:

This system can refresh the screen approximately 162 times per second. This rate is significantly higher than the minimum required to avoid flicker (typically 60 frames per second). Therefore, no, this access rate will not produce flickering. In fact, it will result in a very smooth display.

Key Issues, Hardware, and Software for VR Scene Production

Producing a Virtual Reality (VR) scene requires addressing several key issues to create a realistic and immersive experience, along with specific hardware and software tools.

Key Issues in VR Scene Production

1. Realism and Immersion:
   • Visual Fidelity: High-resolution, realistic textures, and advanced lighting are required to make the virtual environment believable.
2. Latency and Response Time:
   • Motion Sickness: Delays in user interaction or system lag can cause discomfort and motion sickness. High frame rates (60-120 FPS) and low latency are essential to minimize this.
3. Tracking Accuracy:
   • Head Tracking: Accurate tracking of head movements ensures that the user’s viewpoint adjusts correctly and smoothly to the virtual scene.
4. Interactivity:
   • User Interface (UI): VR scenes require intuitive, interactive user interfaces that are easy to navigate while maintaining immersion.
5. Hardware Constraints:
   • Processing Power: VR applications are computationally intensive. High-end graphics processing units (GPUs) and fast processors are required to render high-quality, immersive scenes without lag.

Hardware Used in VR

1. Head-Mounted Displays (HMDs): The primary device for displaying VR content. Popular examples include:
   • Oculus Rift (Meta Quest)
   • HTC Vive
   • PlayStation VR
2. Motion Tracking Sensors:
   • Gyroscopes, Accelerometers, and Magnetometers: These sensors track head and body movement, providing positional and rotational data.
3. Controllers: Hand-held controllers (e.g., Oculus Touch controllers, HTC Vive controllers) track user movements, allowing interaction with virtual objects and environments.
4. High-Performance Computers or Consoles:
   • Graphics Card (GPU): High-end GPUs like NVIDIA RTX or AMD Radeon are crucial for rendering complex scenes in real-time.

Software Used in VR

1. Game Engines: Game engines are used to design, develop, and render VR scenes. They provide comprehensive tools and features required to create immersive VR environments. Examples include Unity and Unreal Engine.
2. 3D Modeling and Animation Software: Used to create the assets (models, animations, textures) that populate the VR scene. Examples include Blender, Autodesk Maya, and ZBrush.
3. VR Development SDKs and APIs: Software Development Kits (SDKs) facilitate the development of VR applications by providing libraries, functions, and tools specific to VR platforms. Examples include Oculus SDK, OpenVR, and SteamVR SDK.
4. Rendering Techniques:
   • Real-Time Rendering: VR applications demand real-time rendering with high frame rates (60-120 FPS) to ensure a smooth and comfortable user experience.

Midpoint Circle Algorithm: Drawing a Circle (Radius 5, Center 10,5)

Let’s calculate the points to draw a circle with radius 5 and center at (10,5) using the Midpoint Circle Drawing Algorithm.

Algorithm Setup:

• Center: (x_c, y_c) = (10, 5)
• Radius: r = 5
• Initial Point: (x, y) = (0, 5) (for a circle centered at origin)
• Initial Decision Parameter: p₀ = 1 − r = 1 − 5 = −4

We will compute points in the first octant (where x increases and y decreases) and then use 8-way symmetry to derive all other circle points relative to the center (10,5).

Iterations:

Iteration 1:

• x = 0, y = 5, p = −4
• Since p < 0 ⇒ Next point: x = 1, y = 5
• Update p = p + 2x + 3 = −4 + 2(0) + 3 = −1

Plot 8-way symmetric points (relative to (10,5)):

• (10+0, 5+5) = (10,10)
• (10+0, 5-5) = (10,0)
• (10+5, 5+0) = (15,5)
• (10-5, 5+0) = (5,5)

Iteration 2:

• x = 1, y = 5, p = −1
• Since p < 0 ⇒ Next point: x = 2, y = 5
• Update p = p + 2x + 3 = −1 + 2(1) + 3 = 4

Points (relative to (10,5)):

• (10+2, 5+5) = (12,10)
• (10+2, 5-5) = (12,0)
• (10-2, 5+5) = (8,10)
• (10-2, 5-5) = (8,0)
• (10+5, 5+2) = (15,7)
• (10-5, 5+2) = (5,7)
• (10+5, 5-2) = (15,3)
• (10-5, 5-2) = (5,3)

Iteration 3:

• x = 2, y = 5, p = 4
• Since p ≥ 0 ⇒ Next point: x = 3, y = 4 (y decreases)
• Update p = p + 2x − 2y + 5 = 4 + 2(2) − 2(5) + 5 = 3

Points (relative to (10,5)):

• (10+3, 5+4) = (13,9)
• (10+3, 5-4) = (13,1)
• (10-3, 5+4) = (7,9)
• (10-3, 5-4) = (7,1)
• (10+4, 5+3) = (14,8)
• (10-4, 5+3) = (6,8)
• (10+4, 5-3) = (14,2)
• (10-4, 5-3) = (6,2)

Iteration 4:

• x = 3, y = 4, p = 3
• Since p ≥ 0 ⇒ Next point: x = 4, y = 3 (y decreases)
• Update p = p + 2x − 2y + 5 = 3 + 2(3) − 2(4) + 5 = 6

Points (relative to (10,5)):

• (10+4, 5+3) = (14,8)
• (10+4, 5-3) = (14,2)
• (10-4, 5+3) = (6,8)
• (10-4, 5-3) = (6,2)
• (10+3, 5+4) = (13,9)
• (10-3, 5+4) = (7,9)
• (10+3, 5-4) = (13,1)
• (10-3, 5-4) = (7,1)

Iteration 5:

• x = 4, y = 3, p = 6
• Since p ≥ 0 ⇒ Next point: x = 5, y = 2 (y decreases)
• At this point, x (5) is greater than y (2), so we stop the iteration as we have crossed the 45-degree line.

Points (relative to (10,5)):

• (10+5, 5+2) = (15,7)
• (10+5, 5-2) = (15,3)
• (10-5, 5+2) = (5,7)
• (10-5, 5-2) = (5,3)
• (10+2, 5+5) = (12,10)
• (10-2, 5+5) = (8,10)
• (10+2, 5-5) = (12,0)
• (10-2, 5-5) = (8,0)

Final List of Unique Circle Points (relative to center (10,5)):

(10,10), (10,0), (15,5), (5,5),
(12,10), (12,0), (8,10), (8,0),
(13,9), (13,1), (7,9), (7,1),
(14,8), (14,2), (6,8), (6,2),
(15,7), (15,3), (5,7), (5,3)

Graphics Clipping Algorithm Fundamentals

Clipping is the process of removing parts of objects (such as lines, polygons, or text) that lie outside a defined region, known as the clipping window. It is an essential step in rendering to optimize performance and ensure only visible content is processed and displayed.

General Clipping Algorithm Steps:

1. Compute Outcodes: Assign a region code (outcode) to both endpoints of the line segment.
2. Trivial Acceptance/Rejection:
   • If both outcodes are 0000 (meaning both endpoints are inside the clipping window), the line is fully inside → Accept.
   • If the logical AND of the outcodes is not 0000 (meaning both endpoints are on the same ‘outside’ side), the line is fully outside → Reject.
3. Partial Clipping: If neither of the above conditions is met, the line is partially inside. In this case:
   • Use the outcode to determine which clipping boundary the line intersects.
   • Calculate the intersection point with that boundary.
   • Replace the outside endpoint with the new intersection point.
   • Repeat steps 1-3 until the line segment is either trivially accepted or rejected.

Example: Line Clipping

Consider a clipping window defined by:

• xmin = 10, xmax = 300
• ymin = 10, ymax = 30

And a line segment: P1 = (5, 5), P2 = (25, 25)

Step 1: Compute Outcodes

• P1 = (5, 5): This point is to the left of xmin (5 < 10) and below ymin (5 < 10). Assuming a standard outcode representation (e.g., Top, Bottom, Right, Left), its outcode would be 0101 (Bottom, Left).
• P2 = (25, 25): This point is within the x-range (10 ≤ 25 ≤ 300) and within the y-range (10 ≤ 25 ≤ 30). Its outcode is 0000 (Inside).

Step 2: Logical AND of Outcodes

Outcode(P1) AND Outcode(P2) = 0101 AND 0000 = 0000

Since the result is 0000, the line is not trivially rejectable. Since P2 is inside and P1 is outside, we proceed to clip.

Step 3: Clip Point P1

P1 (5,5) is outside. We need to clip it against the boundaries. Let’s start with the bottom boundary (y = 10) since P1 is below it.

Line equation from P1 to P2:

• Slope (m) = (y2 – y1) / (x2 – x1) = (25 – 5) / (25 – 5) = 20 / 20 = 1
• Using the point-slope form: y - y1 = m(x - x1) ⇒ y - 5 = 1(x - 5)

To find the intersection with y = 10:

• 10 - 5 = 1(x - 5)
• 5 = x - 5
• x = 10

The new point for P1 is (10, 10). Now, both (10,10) and (25,25) are inside the clipping window. The clipped line segment is from (10,10) to (25,25).

Using Decision Parameters in Circle Drawing Algorithms

To draw a circle efficiently using only integer calculations, we typically employ algorithms that utilize decision parameters, such as the Midpoint Circle Drawing Algorithm. This method is an efficient way to determine the next pixel to plot for a circle.

Principle of Decision Parameters:

A circle is symmetric in all 8 octants, meaning we only need to compute 1/8 of the circle (e.g., from x=0 to x=y in the first octant) and then mirror these points to generate the full circle. The decision parameter (often denoted as p or d) is a value calculated from the circle equation, evaluated at the midpoint between two candidate pixels. Its sign (positive or negative) indicates which pixel is closer to the true circle, thus guiding the choice for the next pixel.

For a circle centered at (0,0) with radius r, or any center (x_c, y_c) using symmetry, the algorithm proceeds by iteratively choosing between two candidate pixels (e.g., (x+1, y) or (x+1, y-1) in the first octant). The decision parameter is updated at each step based on the chosen pixel, ensuring that the algorithm always selects the pixel closest to the ideal circle arc.

Example: Circle of Radius 5 (Midpoint Algorithm)

Let’s consider a circle of radius 5, centered at the origin for simplicity of the decision parameter calculation:

• Initial Point: (x, y) = (0, 5)
• Initial Decision Parameter: p = 1 − r = 1 − 5 = −4

Iterations:

• First point: (0,5)
• Next:
  • If p < 0: Choose (x+1, y). Update p = p + 2x + 3.
  • If p ≥ 0: Choose (x+1, y-1). Update p = p + 2x − 2y + 5.
• Applying this:
  • x=0, y=5, p=−4. Since p<0 ⇒ next x=1, y=5. New p = −4 + 2(0) + 3 = −1.
  • x=1, y=5, p=−1. Since p<0 ⇒ next x=2, y=5. New p = −1 + 2(1) + 3 = 4.
  • x=2, y=5, p=4. Since p≥0 ⇒ next x=3, y=4. New p = 4 + 2(2) − 2(5) + 5 = 3.
  • …and so on, until x ≥ y.

At each step, the chosen (x,y) point and its 7 symmetric counterparts (relative to the circle’s actual center) are plotted to form the complete circle.

Geometric Transformations: Reflection and Rotation Equivalence

Let’s determine the value of alpha (α) such that reflection about the line Y=x is equivalent to reflection along the x-axis followed by a counter-clockwise rotation by alpha degrees.

1. Reflection about the line y = x

The transformation matrix for reflection about the line y = x is:

R_yx = | 0  1 |
       | 1  0 |

2. Sequence of Transformations:

a. Reflection about the x-axis:

The transformation matrix for reflection about the x-axis is:

R_x = | 1  0 |
      | 0 -1 |

b. Counter-clockwise rotation by angle α:

The transformation matrix for a counter-clockwise rotation by angle α is:

Rot_α = | cos(α)  -sin(α) |
        | sin(α)   cos(α) |

3. Equivalence Calculation:

We need to find α such that R_yx = Rot_α × R_x

| 0  1 |   =   | cos(α)  -sin(α) |   ×   | 1  0 |
| 1  0 |       | sin(α)   cos(α) |       | 0 -1 |

| 0  1 |   =   | cos(α)*1 + (-sin(α))*0    cos(α)*0 + (-sin(α))*(-1) |
| 1  0 |       | sin(α)*1 + cos(α)*0       sin(α)*0 + cos(α)*(-1)    |

| 0  1 |   =   | cos(α)   sin(α)  |
| 1  0 |       | sin(α)  -cos(α) |

By comparing the elements of the matrices:

• cos(α) = 0
• sin(α) = 1

For these conditions to be true, α must be 90 degrees (or π/2 radians).

Final Answer:

α = 90 degrees

Therefore, reflection about the line y = x is equivalent to a reflection about the x-axis followed by a 90° counter-clockwise rotation.

Cohen-Sutherland Clipping Example: Line Segment P1(-5,3) to P2(15,9)

Let’s apply the Cohen-Sutherland Line Clipping Algorithm to clip the line segment P1(-5,3) to P2(15,9) against a clipping window with diagonal coordinates (0,0) and (10,10).

Clipping Window Definition:

• xmin = 0, ymin = 0
• xmax = 10, ymax = 10

Step 1: Define Region Codes (Outcodes)

The 4-bit outcode is typically ordered as Top | Bottom | Right | Left.

Step 2: Compute Outcodes for P1 and P2

• P1(-5, 3):
  • x = -5 < xmin (0) → Left = 1
  • y = 3 is between ymin (0) and ymax (10) → Top = 0, Bottom = 0
  • x = -5 is not > xmax (10) → Right = 0
  • Outcode for P1: 0001
• P2(15, 9):
  • x = 15 > xmax (10) → Right = 1
  • y = 9 is between ymin (0) and ymax (10) → Top = 0, Bottom = 0
  • x = 15 is not < xmin (0) → Left = 0
  • Outcode for P2: 0010

Check for Trivial Acceptance/Rejection:

• Both outcodes are not 0000, so not trivially accepted.
• Bitwise AND of outcodes: 0001 AND 0010 = 0000. Since the result is 0000, the line is not trivially rejected. This means the line is partially inside and needs clipping.

Step 3: Clip the Line Segment

We will clip P1 and P2 against the boundaries. Let’s use the slope-intercept form or parametric form for line intersection. The slope (m) of the line P1P2 is:

m = (y2 - y1) / (x2 - x1) = (9 - 3) / (15 - (-5)) = 6 / 20 = 0.3

Clipping P1(-5,3) against the Left Boundary (x = 0):

P1 has the ‘Left’ bit set (0001). We intersect with x = 0.

Using the line equation y = y1 + m(x - x1):

y = 3 + 0.3 * (0 - (-5))
y = 3 + 0.3 * 5
y = 3 + 1.5
y = 4.5

The new point for P1 is P1′ = (0, 4.5). Its outcode is now 0000 (inside).

Clipping P2(15,9) against the Right Boundary (x = 10):

P2 has the ‘Right’ bit set (0010). We intersect with x = 10.

Using the line equation y = y1 + m(x - x1) (using original P1 as reference for line equation):

y = 3 + 0.3 * (10 - (-5))
y = 3 + 0.3 * 15
y = 3 + 4.5
y = 7.5

The new point for P2 is P2′ = (10, 7.5). Its outcode is now 0000 (inside).

Final Clipped Line Segment:

The line segment is clipped to:

From: (0, 4.5)
To:   (10, 7.5)

Both new endpoints P1′ and P2′ have outcodes of 0000, so the line segment is now completely inside the clipping window.