Geometry in Motion
==================

MapPoint is a geometry program which combines the traditional geometric 
constructions of classical Euclidean geometry with the more dynamic geometric 
transformations of modern geometry. Many examples are given showing how to 
create, transform and animate whole configurations of lines, circles or 
polygons in the plane and in space. In fact anything that can be drawn can be 
transformed. 

Directories
-----------

MapPoint has several hundred functions, so the program is organized into 20 
directories (although it is easy to merge all the files into one big stew): 

archimed	archimed
complex 	complex.eg
curves		curves.eg
draw
euclid		euclid.eg
euclid3d	euclid3d.eg
mappings	mappings.eg
ntuples
polyhedr	polyhedr.eg
surfaces	surfaces.eg
triangle	triangle.eg

Entering <<loadall at the level of these directories will load in all the files 
from lower levels. 

In each of the ".eg" directories there is a file with the extension ".egs" 
(triangles.egs, euclid.egs, etc) which gives a summary of the examples in that 
directory. The other files in such a directory are example files, all with the 
extension ".eg". The directories without an extension are made up of many small 
files with the extension ".m" which define less specific functions; these files 
usually define just one function so that a directory listing can act as an 
index. 

The directory triangle.eg has examples of animations of some famous triangle 
theorems: Dudeney's dissection and the theorems of Napoleon, Feuerbach and 
Morley. The corresponding directory called triangle has files that define 
functions like Median, AngleBisector and Circumcircle. 

The directory euclid.eg has a couple of little symmetry guessing games; 
euclid3d.eg has an inverted cylinder and the composition of two rotations in 
space using quaternions. The ".m" files in the directories euclid and euclid3d 
have definitions of basic geometric functions and constructions. For instance, 
Meet, defined in meet.m and meet3d.m, calculates the intersections of lines, 
circles, planes and spheres. 

The directories mappings.eg and polyhedr.eg contain dozens of examples of 
symmetry and geometric transformations in two and three dimensions. 

The directory complex.eg has examples of conformal mappings in the plane and on 
the Riemann sphere. Finally, in curves.eg and surfaces.eg there are examples 
from the elementary differential geometry of curves and surfaces. There are 
many animations in these three directories. 

Transforming Graphics
---------------------

Now let us explain the technique that gives MapPoint its name. The functions 
discussed here are in the directory mappings. Suppose g is something that can 
be drawn - a graphics object. For example, let g be the colored triangle in 
space: 

	{
		PointSize[.05], {Red, Point[x]}, {Blue, Point[y]}, 
			{Green, Point[z]}, 
		Thickness[.05], {Red, Line[{y, z}], {Blue, Line[[{z, x}], 
			{Green, Line[{x, y}]}
	}, 

where x, y and z are n-tuples. Suppose that p is a Plane (a new graphics 
primitive which we will discuss soon). Then Reflect[p] is the function that 
reflects in the plane p. If we write h = Reflect[p][g], both g and h are 
graphics objects, and p is a parameter to the function Reflect. So we can 
display the plane with the triangle and its reflection in p by entering Draw3D[ 
{p, g, Reflect[p][g]} ]. (We can transform the result h again before drawing. 
If q is some other plane, Reflect[q] @ Reflect[p] @ g is the reflection of g in 
p and then in q.)

In fact Reflect[p][g] is 

	{
		PointSize[.05], {Red, Point[X]}, {Blue, Point[Y]}, 
			{Green, Point[Z]}, 
		Thickness[.05], {Red, Line[{Y, Z}], {Blue, Line[[{Z, X}], 
			{Green, Line[{X, Y}]}
	},

where X, Y and Z are the reflections of x, y and z in p. Reflect[p] is first 
defined with an argument that is a point. Then using the functions Position and 
MapAt its domain is extended to all graphics objects as follows. The pointwise 
version of Reflect[p] reaches down and acts on the underlying n-tuples of 
numbers in g that are the arguments of Point and Line, without affecting either 
the list structure of g nor the modifiers RGBColor, PointSize or Thickness. 

The definitions of Translate and Rotate, are written in a similar way. Dilate 
and Invert are more difficult to code, because we want to be careful about what 
happens to lines, circles, planes and spheres. Compositions of the basic types 
give the other motions: HalfTurn, Glide, CentralInversion, Twist, 
RotatoryReflection, and RotatoryInversion. All of these transformations are 
listable. For example, if g is a motif and l is a lattice of points, then 
Translate[l][g] is a wallpaper pattern. 

Transformation[f] makes the complex function f of a complex variable into a 
transformation that acts on figures in the Gauss plane. For example we can take 
the Sin or square of a wallpaper pattern. We can also send both the figure and 
its image under the function up to the Riemann sphere using stereographic 
projection. 

Mapping[f] is similar, but now f is a vector valued function of a vector 
variable. The wallpaper can now be mapped from the plane onto a surface. 

Three-dimensional Primitives
----------------------------

Let us introduce three new abstract graphics primitives. Circle3D[c, d, e] 
represents a circle with centre c and with d and e being two points on the 
circumference, not on the same diameter. Plane[{p, q, r}] represents a plane 
through the points p, q and r, not all on the same line. Finally, Sphere[c, r] 
represents a sphere with centre at c and radius r. 

We need these fundamental geometric objects for both constructions and 
transformations. They are "abstract" in the sense that the functions Plane, 
Circle3D and Sphere are never actually evaluated. The functions hold their 
arguments for use by other functions. We mentioned that Meet finds the 
intersection of various combinations of Lines, Circles, Planes and Spheres. In 
three dimensions, we saw that Reflect takes a Plane for an argument; Invert 
takes a Sphere as an argument. 

To invert a cylinder in a sphere, we use Lines and Circle3D's as generating 
lines and circles. It is much faster to transform the three parameters of 
Circle3D than each of the 100 or so points that will eventually be used to draw 
a circle. Draw3D will draw the circles in space after all the transformations 
are done. 

Graphics objects are shown on the screen with Draw and Draw3D, defined in 
draw.m in the directory draw. These functions are first of all abbreviations 
for the typical combinations of Show with Graphics and Show with Graphics3D, 
with the expected options. Secondly, there is now no longer any need to be 
concerned with whether a figure is in the plane or in space. Draw[g] shows the 
figure g in the plane, and Draw3D[g] gives a bird's-eye-view. The projection of 
a 3D figure h into the plane is Draw[h]. 

Drawing Figures
---------------

Draw and Draw3D call the functions PreDraw and PreDraw3D which prepare the 
graphics primitives (old or new!), into drawable Points, Lines and Polygons. 
The user can redefine the way graphics primitives are drawn. A plane is usually 
drawn as an open rectangular frame, so that it doesn't block the view, but we 
can draw it as a flat ring to show it with more symmetry. We put a black border 
around polygons in the plane to distinguish overlapping polygons. 

Points need to be entered as n-tuples of real numbers in order for Draw and 
Draw3D to work. The words point, n-tuple and vector are interchangeable, but do 
not confuse point and Point. The latter is a graphics primitive that takes a 
point for an argument. The global variables $i, $j and $k represent the unit 
vectors along the x, y and z axes, and the global variable $o represents the 
origin. Other points should be expressed in terms them. Using points of the 
wrong length will cause bugs. The global variable $Dimension determines 
the length of the n-tuples. Right now all of our examples use $Dimension = 3
so the n-tuples are triples, but the system will work with higher dimensions.