Computer Graphics

Computer Graphics: A Deep Dive

Computer graphics is a field of computer science that deals with the creation, manipulation, and display of images and visual effects. It involves a wide range of techniques, from simple 2D line drawing to complex 3D rendering.

Line Drawing Algorithms

Line drawing is a fundamental technique in computer graphics. Two popular algorithms for line drawing are the Digital Differential Analyzer (DDA) algorithm and Bresenham's line algorithm.

DDA Algorithm The DDA algorithm is a simple algorithm that calculates the difference between the endpoints of a line and increments the x and y coordinates based on the slope of the line.

def dda_line(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    steps = max(abs(dx), abs(dy))
    x_inc = dx / steps
    y_inc = dy / steps
    x = x1
    y = y1
    for i in range(steps + 1):
        putpixel(round(x), round(y))
        x += x_inc
        y += y_inc

Bresenham's Line Algorithm Bresenham's algorithm is a more efficient algorithm that uses integer arithmetic to determine the next pixel to be plotted.

def bresenham_line(x1, y1, x2, y2):
    dx = abs(x2 - x1)
    dy = abs(y2 - y1)
    p = 2 * dy - dx
    x, y = x1, y1
    if x2 > x1:
        x_inc = 1
    else:
        x_inc = -1
    if y2 > y1:
        y_inc = 1
    else:
        y_inc = -1
    putpixel(x, y)
    for i in range(dx):
        x += x_inc
        if p < 0:
            p += 2 * dy
        else:
            p += 2 * (dy - dx)
            y += y_inc
        putpixel(x, y)

Circle Drawing Algorithms

Two common algorithms for drawing circles are Bresenham's circle algorithm and the midpoint circle algorithm.

Bresenham's Circle Algorithm Bresenham's circle algorithm is an efficient algorithm for drawing circles using integer arithmetic.

def bresenham_circle(xc, yc, r):
    x = 0
    y = r
    p = 3 - 2 * r
    putpixel(xc + x, yc + y)
    putpixel(xc - x, yc + y)
    putpixel(xc + x, yc - y)
    putpixel(xc - x, yc - y)
    while x < y:
        x += 1
        if p < 0:
            p += 2 * x + 1
        else:
            y -= 1
            p += 2 * (x - y) + 1
        putpixel(xc + x, yc + y)
        putpixel(xc - x, yc + y)
        putpixel(xc + x, yc - y)
        putpixel(xc - x, yc - y)
        putpixel(xc + y, yc + x)
        putpixel(xc - y, yc + x)
        putpixel(xc + y, yc - x)
        putpixel(xc - y, yc - x)

Midpoint Circle Algorithm The midpoint circle algorithm is another efficient algorithm for drawing circles. It determines the next pixel to be plotted based on the sign of the midpoint between the current pixel and the ideal circle.

def midpoint_circle(xc, yc, r):
    x = 0
    y = r
    p = 1 - r
    putpixel(xc + x, yc + y)
    putpixel(xc - x, yc + y)
    putpixel(xc + x, yc - y)
    putpixel(xc - x, yc - y)
    while x < y:
        x += 1
        if p < 0:
            p += 2 * x + 1
        else:
            y -= 1
            p += 2 * (x - y) + 1
        putpixel(xc + x, yc + y)
        putpixel(xc - x, yc + y)