Computing a Straight Line in Integers

Intro

"Computer Graphics Principles and Practice" by Foley, van Dam, Feirner and Hughes, second edition discusses several raster graphics algorithms for drawing 2D primitives. The midpoint line algorithm, the midpoint circle algorithm, midpoint ellipse scan-conversion algorithm and finally the scan-line algorithm.

I say finally because all these algorithms share the same way of computing. The algorithms were introduced in that order, but by far the simplest is the method used to compute the straight line. Its buried in the scan-line algorithm. See page 97 LeftEdgeScan procedure.

Call the algorithm to compute the straight line in integers the Line Algorithm.

Problem Description

On a integer grid points are placed to approximate a straight line, through the origin to simplify the maths. Let both end points lie on the grid.
ie $(0, 0)$ and $(a, b)$ be the end points of the straight line. Let $b > a$ .

Derive the following algorithm as given in Computer Graphics page 97 LeftEdgeScan procedure. It has been adapted - the notation changed for simplicity.

$y_{k + 1} = y_{k} + 1$
$x_{k + 1} = x_{k} + (f_{k} > b)$
$f_{k + 1} = f_{k} + a + (f_{k} > b) . - b$

Algorithm Discussion

The restriction that $b > a$ is to guarantee the change in y to be constant. A point is generated from a previous point and its state(the f variable holds the state).

For other curves the curve is divided into regions where one of the variables has a constant change of unity.

The x variable has either no change or changes by 1.

The issue here is how the algorithm works. I am happy that its simple to implement, and can see the same technique being used in similar algorithms, but whats driving it? Can it be shown indeed to approximate the straight line. Its like a limit but it never really converges to an exact solution because the arithmetic is in integers - which makes it really interesting. Here is something fundamentally different to the standard "maths" view of reality - its like a discrete limit but there isn't any language in common use to describe this.

I hope that I have shown that there is something deeper here, and that its a problem worthy of attention. So faced with this situation the question remains how do you analyze it?

Order Driven Algebra Analysis

The following uses an Order Driven Algebra . Essentially you can not interchange the sides of the equation. For example the f variable will be defined on the lhs and needs to stay on the lhs throughout the calculation. I am growing algebra.

$y = \frac{b}{a} x$
$a y_{k} \approx b x_{k}$

Although the approximate symbol is being employed it does not say why. In a sense the magnitude of the difference from the exact solution diminishes compared with the magnitude of x and y, which is what happens in a limit. In short its a discrete form of a limit.

Increment the system.

$a (y_{k + 1}) \approx b (x_{k + 1})$
$a (y_{k} + 1) \approx b (x_{k} + t)$ where $t = {0, 1}$
$a y_{k} + a \approx b x_{k} + b t$

Now the change in y was known so y was incremented by one. The change in x is unknown and called t which is either 0 or 1.

Express the equation on one side. f is essentially the straight line equation.

Let
$f_{k} = a y_{k} - b x_{k}$ on the lhs.
$f_{k} \approx 0$

Similarly we would expect
$f_{k + 1} \approx 0$

Consider the difference and substitute the result from the incremented equation.

$f_{k} = 0$ relative to $f_{k + 1}$
$f_{k + 1} - f_{k} = a y_{k + 1} - b x_{k + 1} - a y_{k} + b x_{k}$
$f_{k + 1} = f_{k} + a - b t$

Now as you may have noticed there is almost a one-one correlation between the given algorithm and the derived algorithm.

$t = (f_{k} > b)$

Solving for t

Divide f by b and consider the change along the x-axis.

Let
$g_{k} = f_{k} / b$
$g_{k + 1} = g_{k} + \frac{a}{b} - t \approx 0$

Let $g_{k} > 0$

This restricts the change to one side of the line. It also turns out to be the condition to solve the system.

$g_{k + 1} > 0$
$g_{k} + \frac{a}{b} - t > 0$
$g_{k} - t > 0$
If this equation is true, so is the previous equation.

Solve
$g_{k} - t > 0$
Case $t = 0$ $g_{k} > 0$ is always true.
Case $t = 1$ $g_{k} > 1$
Both conditions satisfied when $g_{k} > 1$ .
Let $t = (g_{k} > 1)$

$t = (g_{k} > 1)$
$t = (\frac{f_{k}}{b} > 1)$
$t = (f_{k} > b)$