Unit 1: Graphics algorithm implementation

• graphics.h is the Borland BGI library used in Turbo C++. On modern systems use WinBGIm with Code::Blocks or Dev-C++ (link libbgi, libgdi32, libcomdlg32, libuuid, libole32, liboleaut32), or a DOS emulator running Turbo C++. Every program starts with initgraph and ends with closegraph.

cpp#include <graphics.h>
#include <conio.h>
int main() {
    int gd = DETECT, gm;
    initgraph(&gd, &gm, (char*)"");     // "C:\\TURBOC3\\BGI" in Turbo C++
    // drawing code
    getch();
    closegraph();
    return 0;
}

cppsetcolor(YELLOW);
circle(150, 150, 60);
setfillstyle(SOLID_FILL, BLUE);
floodfill(150, 150, YELLOW);            // fill inside the yellow circle
setcolor(WHITE);
rectangle(250, 100, 400, 200);
arc(500, 150, 0, 180, 50);
ellipse(320, 320, 0, 360, 100, 50);
putpixel(320, 320, RED);
outtextxy(260, 400, (char*)"Basic shapes");

cpp// Moving car: draw, wait, erase, shift
for (int x = 0; x < getmaxx() - 120; x += 5) {
    setcolor(WHITE);
    rectangle(x, 300, x + 120, 340);          // body
    rectangle(x + 25, 270, x + 95, 300);      // roof
    circle(x + 25, 350, 12);                  // wheels
    circle(x + 95, 350, 12);
    delay(30);
    cleardevice();
}

• Double buffering with setactivepage and setvisualpage removes flicker in WinBGIm.

cppvoid directLine(int x1, int y1, int x2, int y2) {
    float m = (float)(y2 - y1) / (x2 - x1);   // assumes x1 < x2 and abs(m) <= 1
    float c = y1 - m * x1;
    for (int x = x1; x <= x2; x++) putpixel(x, (int)(m * x + c + 0.5), WHITE);
}

cpp#include <cmath>
void ddaLine(int x1, int y1, int x2, int y2) {
    int dx = x2 - x1, dy = y2 - y1;
    int steps = abs(dx) > abs(dy) ? abs(dx) : abs(dy);
    float xinc = dx / (float)steps, yinc = dy / (float)steps;
    float x = x1, y = y1;
    for (int i = 0; i <= steps; i++) {
        putpixel((int)round(x), (int)round(y), GREEN);
        x += xinc; y += yinc;
    }
}

cppvoid bresLine(int x1, int y1, int x2, int y2) {
    int dx = abs(x2 - x1), dy = abs(y2 - y1);
    int sx = x1 < x2 ? 1 : -1, sy = y1 < y2 ? 1 : -1;
    int err = dx - dy;
    while (true) {
        putpixel(x1, y1, CYAN);
        if (x1 == x2 && y1 == y2) break;
        int e2 = 2 * err;
        if (e2 > -dy) { err -= dy; x1 += sx; }
        if (e2 <  dx) { err += dx; y1 += sy; }
    }
}

cppvoid plot8(int xc, int yc, int x, int y, int c) {      // eight-way symmetry
    putpixel(xc + x, yc + y, c); putpixel(xc - x, yc + y, c);
    putpixel(xc + x, yc - y, c); putpixel(xc - x, yc - y, c);
    putpixel(xc + y, yc + x, c); putpixel(xc - y, yc + x, c);
    putpixel(xc + y, yc - x, c); putpixel(xc - y, yc - x, c);
}
void polyCircle(int xc, int yc, int r) {
    for (int x = 0; x <= r / sqrt(2.0); x++)
        plot8(xc, yc, x, (int)round(sqrt((double)r * r - x * x)), WHITE);
}
void trigCircle(int xc, int yc, int r) {
    for (double t = 0; t <= M_PI / 4; t += 1.0 / r)
        plot8(xc, yc, (int)round(r * cos(t)), (int)round(r * sin(t)), YELLOW);
}

cppvoid bresCircle(int xc, int yc, int r) {
    int x = 0, y = r, d = 3 - 2 * r;
    while (x <= y) {
        plot8(xc, yc, x, y, MAGENTA);
        if (d < 0) d += 4 * x + 6;
        else { d += 4 * (x - y) + 10; y--; }
        x++;
    }
}

cppvoid plot4(int xc, int yc, int x, int y, int c) {
    putpixel(xc + x, yc + y, c); putpixel(xc - x, yc + y, c);
    putpixel(xc + x, yc - y, c); putpixel(xc - x, yc - y, c);
}
void midEllipse(int xc, int yc, long rx, long ry) {
    long x = 0, y = ry;
    double p1 = ry * ry - rx * rx * ry + 0.25 * rx * rx;
    while (2 * ry * ry * x < 2 * rx * rx * y) {          // region 1
        plot4(xc, yc, x, y, LIGHTGREEN);
        x++;
        if (p1 < 0) p1 += 2 * ry * ry * x + ry * ry;
        else { y--; p1 += 2 * ry * ry * x - 2 * rx * rx * y + ry * ry; }
    }
    double p2 = ry * ry * (x + 0.5) * (x + 0.5) + rx * rx * (y - 1) * (y - 1) - rx * rx * ry * ry;
    while (y >= 0) {                                      // region 2
        plot4(xc, yc, x, y, LIGHTGREEN);
        y--;
        if (p2 > 0) p2 += rx * rx - 2 * rx * rx * y;
        else { x++; p2 += 2 * ry * ry * x - 2 * rx * rx * y + rx * rx; }
    }
}

cpp// A small ball (or the letter A) travels around a circular track
int xc = 320, yc = 240, R = 150;
for (int k = 0; k < 3; k++)                               // three laps
    for (double t = 0; t < 2 * M_PI; t += 0.05) {
        cleardevice();
        setcolor(WHITE); circle(xc, yc, R);              // track
        int x = xc + (int)(R * cos(t)), y = yc + (int)(R * sin(t));
        setcolor(RED); circle(x, y, 10);
        setfillstyle(SOLID_FILL, RED); floodfill(x, y, RED);
        outtextxy(x - 3, y - 25, (char*)"A");
        delay(20);
    }

cpp// Cohen–Sutherland line clipping
const int INSIDE = 0, LEFT = 1, RIGHT = 2, BOTTOM = 4, TOP = 8;
int xmin = 150, ymin = 150, xmax = 450, ymax = 350;      // clipping window

int code(int x, int y) {
    int c = INSIDE;
    if (x < xmin) c |= LEFT;   else if (x > xmax) c |= RIGHT;
    if (y < ymin) c |= BOTTOM; else if (y > ymax) c |= TOP;
    return c;
}
void cohenSutherland(int x1, int y1, int x2, int y2) {
    int c1 = code(x1, y1), c2 = code(x2, y2);
    bool accept = false;
    while (true) {
        if (!(c1 | c2)) { accept = true; break; }        // both inside
        if (c1 & c2) break;                               // both outside same side
        int out = c1 ? c1 : c2; double x, y;
        if (out & TOP)         { x = x1 + (x2 - x1) * (ymax - y1) / (double)(y2 - y1); y = ymax; }
        else if (out & BOTTOM) { x = x1 + (x2 - x1) * (ymin - y1) / (double)(y2 - y1); y = ymin; }
        else if (out & RIGHT)  { y = y1 + (y2 - y1) * (xmax - x1) / (double)(x2 - x1); x = xmax; }
        else                   { y = y1 + (y2 - y1) * (xmin - x1) / (double)(x2 - x1); x = xmin; }
        if (out == c1) { x1 = (int)x; y1 = (int)y; c1 = code(x1, y1); }
        else           { x2 = (int)x; y2 = (int)y; c2 = code(x2, y2); }
    }
    rectangle(xmin, ymin, xmax, ymax);
    if (accept) { setcolor(YELLOW); line(x1, y1, x2, y2); }
}

• Windowing: map a world-coordinate window to a screen viewport with xv = xvmin + (xw − xwmin) × sx and yv = yvmin + (yw − ywmin) × sy; draw the original and the mapped figure side by side to check the result.

• Draw basic shapes with circle, putpixel, rectangle, arc, ellipse, floodfill and setcolor.
• Simple animations: moving car, bouncing ball, rotating fan blades.
• Lines with the direct method, DDA and Bresenham's algorithm; compare output for steep and shallow lines.
• Circles with polynomial, trigonometric and Bresenham's methods.
• Ellipse with Bresenham's (midpoint) algorithm.
• Move a character or ball along a circular path.
• Cohen–Sutherland line clipping; window-to-viewport mapping.