The Mathematics behind Light Speed!
===================================

This file describes the mathematical framework of the relativistic
transforms exhibited in the Light Speed! simulator. In particular, the
formulae and some details of their implementation are given below.



==== THE LORENTZ CONTRACTION ====

A moving object will appear shorter than it does at rest, due to an
oblique alignment in four-dimensional space-time imparted to it by its
motion. Specifically, the object will appear compressed along its axis of
travel, scaled down by a factor which is exactly the Lorentz factor,
also known as gamma:

	                  1
	gamma = ---------------------
	         sqrt( 1 - (v/c)^2 )

where v is the velocity of the object, and c is the speed of light. For
most everyday values of v, gamma is practically 1. As v approaches the
speed of light, however, gamma grows without bound.

Assuming that a vehicle's length L is parallel with its axis of travel,
its observed length L' at any velocity (below that of light!) is:

	L' = L / gamma

This predicts that an object travelling at the speed of light will appear
to have no length (and hence no volume), while retaining its frontal
cross-sectional area. If the object were a rocket, for example, it would
appear to have become a flying disc.



==== THE DOPPLER RED/BLUE SHIFT and THE HEADLIGHT EFFECT ====

     These are transformations upon the color hue and intensity attributes
of an object, respectively. Either is based upon the motion of a light
source (whether by emission or reflection) with respect to a receiver or
observer of its light. If the source is approaching the observer, it will
appear blue-shifted (its light higher in frequency) and brighter. If it is
moving away, it will appear red-shifted (lower in frequency) and darker.
In Light Speed!, there are two instances where these effects are applied:

	1. Ambient light striking (illuminating) the object
	2. The object reflecting light toward the observer

     The first takes into account how the object is illuminated. If the
object were a space vessel, travelling at relativistic speed, an onboard
observer will notice that (for example) stars and planetary bodies ahead
of the ship appear brighter and blue-shifted. Because of this, the nose of
the ship will be bathed in a relatively bright, bluish light. The light it
reflects, then, will also have this character.

     The second instance handles the color effects as naturally expected
from the motion of the object, with respect to the camera.

     Both effects depend on the relative motion between a source point and
a receiving point, one in motion and the other at rest. As such, the
formula for either transform contains the term:

	 v
	--- * cos a
	 c

in which:
 v = forward velocity of the moving point
 c = speed of light
 a = (alpha) angle subtended between the motion vector of the moving point
     and the vector connecting the two points (moving-to-stationary)

This value is nothing more than the rate (as a factor of c, between 1.0
and -1.0) at which the two points are approaching or moving away from one
another.

     With that pointed out, the formula describing the Doppler effect is
as follows:

	 n'      1 + (v/c)*cos a
	--- = ---------------------
	 n     sqrt( 1 - (v/c)^2 )

The n'/n (nu-prime over nu) is a frequency ratio. Multiplying the
frequency of the source lighting by this value will give the frequency as
observed by the receiver.

(Also, note that the denominator is the reciprocal of the gamma factor.
This accounts for the effect of time dilation upon the frequency, which to
some extent always increases it).

     The Doppler shift routines used in Light Speed! were written by
Antony Searle, and actually work with the reciprocal of this value, n/n',
which is the *wavelength* ratio between the two states of light. These
routines are not trivial to produce, as they accept an RGB-triplet color
as input, and produce an RGB-triplet as output. The RGB representation
must be converted to a rough spectrum to make the wavelength ratio
meaningful, and then sampled into RGB again as this is the native color
format of the graphics system. The colors produced are only an
approximation, and make some assumptions as to the character of light
involved, but Mr. Searle's implementation has the important advantage of
computational simplicity-- and thereby speed.

     The formula describing the headlight effect is similar:

	 I'    (1 + (v/c)*cos a)^2
	--- = ---------------------
	 I     sqrt( 1 - (v/c)^2 )

(The only difference to the previous formula is in the squaring of the
numerator)

I'/I is an intensity ratio, again multiplying that of the source light to
produce what is observed by the receiver.

     RGB colors can be directly manipulated by this value (i.e.
multiplying each color component with it), although better intensity
transforms may exist. (Some of the intensity-adjustment routines of
quality paint programs come to mind).



==== OPTICAL ABERRATION ====

     This results from the phenomena of delayed observation; i.e. we do
not see things, but the light reflected from things. As light has a
finite, albeit very high speed, there is a corresponding delay associated
with our observation of events/things.

     In Light Speed!, the camera observes a moving object, which is
comprised of various vertex points (interconnected in some arbitrary
geometrical manner, be it triangles, quads, etc.) The position of each of
these is known within a fiducial time frame, at the moment that the
shutter is snapped. However, the camera perceives by way of light, whose
propagation is not instantaneous. Thus it is necessary to translate each
vertex of the object backward (w.r.t. the direction of travel) to an
earlier position, specifically the position at which the camera is
expected to observe the vertex-- at a slightly earlier point in time.

     There is one condition that this earlier position must satisfy: The
time necessary for the vertex to travel from the earlier position to its
position in the fiducial frame _must_exactly_equal_ the time necessary for
light to travel from the earlier position of the vertex to the observer.


(My apologies; this is very difficult to explain in a straightforward
manner. Let me try a different approach...)


If the object of concern consists of a single vertex, the problem may be
illustrated geometrically as follows:

	A *
	  |\
	  | \
	  |  \
	  |   \
	  |    \
	  |     \
	B *      \
	  |       \
	  |        \
	  |         \
	  |          \
	  |_          \
	  | |          \
	C *-------------* O

	      Fig. 1

     The object is traveling along the vector AC. At time T=-t (i.e. a
short moment before T=0) it is at position A. At this moment, a photon
strikes the object and reflects off its surface, beginning travel along
the vector AO toward the observer O. The object continues along path AC.

     At time T=0, the object is at B, and the photon reaches O. The
observer, seeing the photon, observes an image of the object at position
A. (and, incidentally, has yet to see anything at position B)

     Whereas the image of the object is at A, the object itself is really
at B; in this way we have determined where the object will be-- position
B-- given where its image appears (position A). Implementing a simulator,
however, entails finding the image position A from the actual position B,
taking into account the velocity v of the object and position O of the
observer. The unknown length AB-- the image-to-object delta-- must be
calculated.

     This means calculating t, as AB is simply v*t. (Similarly, AO is
c*t). In the geometrical sense, it is finding lengths AB and AO in the
ratio v/c, scaled by some factor t which will make ACO a right triangle.

     For the sake of argument, let us say AC is the x-axis, with B being
the origin. (This is close to how it is implemented in Light Speed!)

Let:
 x = x-position of the observer = distance BC;
 y = y-position of the observer = distance CO;
 v = velocity of the moving object;
 c = speed of light.

We start off with the right-triangle relationship (a.k.a. the Pythagorean
Theorem), stating the square of the hypotenuse...:

	(c*t)^2 = (v*t + x)^2 + y^2

and then rearrange it into a quadratic equation of t:

	(v^2 - c^2)*t^2 + (2*x*v)*t + (x^2 + y^2) = 0

which yields the solution:

	     -2*x*v - sqrt( (2*x*v)^2 - 4*(v^2 - c^2)*(x^2 + y^2) )
	t = --------------------------------------------------------
	                        2*(v^2 - c^2)

(The sign on the radical must be negative to give a positive value for t.
Note that the denominator is always negative, as v<c)

     This approach can be trivially extended to three dimensions by
defining y as the distance in the YZ plane between the observer and the
object's axis of travel.

     Note that in an actual implementation, x and y do not represent the
position of the observer, but the x- and y-distance between the observer
and a particular vertex of an object. (In the example above, the vertex
was at x=0, y=0, making this distinction moot). This means that each
vertex need not have the same associated value of t, which in turn means
that all the vertices of an object will not necessarily be displaced the
same amount. This is why full-fledged deformation is commonly the result
of this transformation, as opposed to a simple uniform translation of the
object's vertices.



==== ADDITIONAL INFORMATION ====

     More information concerning the theory and physics behind these
relativistic phenomena may be found at Antony Searle's ANU departmental
seminar site, which proved by far to be the most valuble resource in
creating Light Speed!:

	http://www.anu.edu.au/Physics/Searle/Obsolete/Seminar.html

     As for further details of implementation, the ultimate documentation
is the source code itself :-)  I have taken great pains to make it as
transparent as possible, commenting it heavily and using a straightforward
code structure. (Likewise for the entire program). All the code
responsible for the above-described effects is contained within the file
warp.c. Have a peek!



====================================
Daniel Richard G. // <skunk@mit.edu>