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^{2} an ordered pair from R^{2} and
have a onetoone 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^{2}
we must use ordered triples (from R^{3})
for coordinates.
R^{3} turns out to have far more values than
we need. We have to consider sets of triples from R^{3}
as being "equivalent". We will say that two triples are equivalent
if they are proportional, that is, (x_{1},
y_{1}, z_{1}) ~ (x_{2}, y_{2}, z_{2})
if there is a (nonzero) number t such that tx_{1}=
x_{2}, ty_{1} = y_{2},
and tz_{1} = z_{2}. 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 "tripleclass" as t(p, q, r).
We will eventually define two systems, one for points and one for lines.
The goal is to have a tripleclass for each point in
RP^{2}, a tripleclass for each line in RP^{2},
and an easy way to determine if a given point is on a given line or not.
For points, we divide the tripleclasses into two categories:

For each x and y, the tripleclass
t(x, y, 1). We assign each of these tripleclasses 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 tripleclass t(x,
y, 0). We assign each of these tripleclasses to one of the "extra"
points.
For lines, we divide the tripleclasses into two categories:

For each a, b, c, where (x <> 0) or (y <> 0), the tripleclass
t(a, b, c). We assign each of these tripleclasses 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 tripleclass left: t(0, 0, 1). We assign this
tripleclass 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^{n} , we take the set of ordered (n+1)tuples, remove 0^{n},
and then classify point systems t(x_{1}, x_{2},
..., x_{n}, 1) and t(x_{1}, x_{2},
..., x_{n}, 0), and line systems t(a_{1},
a_{2}, ..., 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 pointonline determination equation stated above.
For "ordinary" points at least, it turns out that if a^{2} + b^{2} + c^{2} = 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^{2} + b^{2} + c^{2}) is a bit more FPUintensive than a lot of people like, however.