Homogenous coordinates

A method of assigning coordinates to a real projective space, useful in defining geometric transformations in computer graphics.

A projective plane is an "extended" Euclidean plane: It has had "extra points" added to it so that every pair of lines will intersect at a point (and so that points and lines can be considered interchangeable).

Now, there _is_ a way to assign each point of a projective plane RP² an ordered pair from R² and have a one-to-one correspondence.  Unfortunately, that does not leave us the ability to embed a more familiar Euclidean plane in that space.

So, the answer is to use a larger tuple for our coordinates.  For RP² we must use ordered triples (from R³) for coordinates.

R³ turns out to have far more values than we need.  We have to consider sets of triples from R³ as being "equivalent".  We will say that two triples are equivalent if they are proportional, that is, (x₁, y₁, z₁) ~ (x₂, y₂, z₂) if there is a (non-zero) number t such that tx₁= x₂, ty₁ = y₂, and tz₁ = z₂.  For example:

(1, 1, 1) ~ (2, 2, 2)
(3, 4, 5) ~ (15, 20, 25)
(7.2, 8.1, 0) ~ (0.0072, 0.0081, 0)

Before we continue, notice that the triple (0, 0, 0) is not proportional to any other triple; it is convenient for us to leave it out of our system. In all other cases, we can take a group of three numbers  (p, q, r)  that meet some condition and consider the set of all ordered triples  (t*p, t*q, t*r)  where t can take on any value except 0. We will symbolize such a "triple-class" as t(p, q, r).

We will eventually define two systems, one for points and one for lines.  The goal is to have a triple-class for each point in 
RP², a triple-class for each line in RP², and an easy way to determine if a given point is on a given line or not.

For points, we divide the triple-classes into two categories:

• For each x and y, the triple-class t(x, y, 1). We assign each of these triple-classes to an ordinary point of the Euclidean plane; that is, t(x, y, 1) represents the same point that (x, y) would.
• For each x and y, the triple-class t(x, y, 0). We assign each of these triple-classes to one of the "extra" points.

For lines, we divide the triple-classes into two categories:

• For each a, b, c, where (x <> 0) or (y <> 0), the triple-class t(a, b, c). We assign each of these triple-classes to an ordinary line of the Euclidean plane. This, incidentally shows us where the term "homogenous" comes from. The equation of a line is a linear equation, and since a point can be on two distinct lines only if those lines intersect at the point, the coordinates of a point are the solution of a homogeneous system of linear equations.
• There is one triple-class left: t(0, 0, 1). We assign this triple-class to the "extra" line formed from all of the "extra" points.

We can now present our rule for determining if a given point  t(x, y, s) is on a given line t(a, b, c):  this happens whenever a*x + b*y + c*s = 0.

For "ordinary" points, this is the same as the analytical equation a*x + b*y + c = 0 used to define "ordinary" lines.

This rule also works for the "extra" points.  Each "extra" point t(x, y, 0) is on the "ordinary" line t(-y, x, c), since -y*x+x*y+0*c = 0.  Each "extra" point is also on the "extra" line t(0, 0, 1), since 0*x+0*y+c*0 = 0.

Our system also lets us treat points and lines interchangeably.  For each point t(x, y, s), we can assign its "dual" line t(x, y, s). The dual of the origin of coordinates t(0, 0, 1) is the "extra line", t(0, 0, 1)! Neat, huh?

Our system can be extended to an arbitrary number of dimensions:  to coordinatize RPⁿ , we take the set of ordered (n+1)-tuples, remove 0ⁿ, and then classify point systems t(x₁, x₂, ..., x_n, 1) and  t(x₁, x₂, ..., x_n, 0), and line systems t(a₁, a₂, ..., a_n, c) and t(0, 0, ..., 0, 1).

Homogenous coordinates are useful in computer graphics because we can define coordinate transformations as matrices and use matrix multiplication to stack transformations together. Geometric Transformations in Two Dimensions describes how to do this.

Remember, however, that a point is represented by an infinite set of ordered triples: When you're representing homogenous coordinates in a computer program, it becomes necessary to select a "normal form", that is, a representative triple from the set.

Points are fairly straightforward:  We can take (x, y, 1) as the normal form of an ordinary point, and (x, y, 0) as the normal form of an "extra" point.

Lines aren't defined so well:  There are several ways to do this, depending upon what you are trying to accomplish.  My favorite method arises from the point-on-line determination equation stated above.  For "ordinary" points at least, it turns out that if a² + b² + c² = 1, then a*x + b*y + c*s is the distance from the point to the line!  This method also spreads any rounding error out across the entire projective plane.  Dividing your line's coordinates by sqrt (a² + b² + c²) is a bit more FPU-intensive than a lot of people like, however.