Venturing into a 3D World: Math for Java Game Programmers

  public static GM01.ColMatrix2D convert3Dto2D(
                                   GM01.ColMatrix3D data){
    return new GM01.ColMatrix2D(
                  data.getData(0) - 0.866*data.getData(2),
                  data.getData(1) - 0.50*data.getData(2));
  }//end convert3Dto2D

The transform equations are:
 x2d = x3d + z3d * cos(theta)/tan(alpha)
 y2d = y3d + z3d * sin(theta)/tan(alpha);

Let alpha = 45 degrees and theta = 30 degrees
Then:  cos(theta) = 0.866
       sin(theta) = 0.5
       tan(alpha) = 1;

Note that the signs in the above equations depend
 on the assumed directions of the angles as well as
 the assumed positive directions of the axes. The
 signs used in this method assume the following:
   Positive x is to the right.
   Positive y is up the screen.
   Positive z is protruding out the front of the
     screen.
   The viewing position is above the x axis and to the
     right of the z-y plane.

Test overridden toString of ColMatrix2D
1.5,2.5

Test setData and getData of ColMatrix2D
4.5
5.5

Test equals method of ColMatrix2D
false
true

Test add method of ColMatrix2D
9.0,11.0

Test subtract method of ColMatrix2D
0.0,0.0

Test toString method of Point2D
4.5,5.5

Test setData and getData of Point2D
1.1
2.2

Test getColMatrix method of Point2D
1.1,2.2

Test equals method of Point2D
false
true

Test getDisplacementVector method of Point2D
1.5,2.5
4.5,5.5
3.0,3.0

Test addVectorToPoint method of Point2D
1.5,2.5
7.0,9.0

Test toString method of Vector2D
1.5,2.5

Test setData and getData methods of Vector2D
4.5
5.5

Test getColMatrix method of Vector2D
4.5,5.5

Test equals method of Vector2D
false
true
Test add method of Vector2D
4.5,5.5
-1.5,3.5
3.0,9.0

Test getLength method of Vector2D
3.0,4.0
5.0

Test toString method of Line2D
Tail = 1.5,2.5
Head = 4.5,5.5

Test setTail, setHead, getTail,
and getHead methods of Line2D
4.5,5.5
1.5,2.5

    //Perform tests using text.
    testUsingText();

    //Perform tests using graphics.
    drawOffScreen(g2D);

    public void draw(Graphics2D g2D){

      //Get 2D projection coordinate values.
      ColMatrix2D temp = convert3Dto2D(point);
      drawOval(g2D,temp.getData(0)-3,
                   temp.getData(1)+3,
                   6,
                   6);
    }//end draw

    public void draw(Graphics2D g2D,GM01.Point3D tail){

      //Get a 2D projection of the tail
      GM01.ColMatrix2D tail2D = convert3Dto2D(tail.point);

      //Get the 3D location of the head
      GM01.ColMatrix3D head = 
                      tail.point.add(this.getColMatrix());

      //Get a 2D projection of the head
      GM01.ColMatrix2D head2D = convert3Dto2D(head);
      drawLine(g2D,tail2D.getData(0),
                   tail2D.getData(1),
                   head2D.getData(0),
                   head2D.getData(1));

      //Draw a small filled circle to identify the head.
      fillOval(g2D,head2D.getData(0)-3,
                   head2D.getData(1)+3,
                   6,
                   6);

    }//end draw

    public void draw(Graphics2D g2D){

      //Get 2D projection coordinates.
      GM01.ColMatrix2D tail = 
                           convert3Dto2D(getTail().point);
      GM01.ColMatrix2D head = 
                           convert3Dto2D(getHead().point);

      drawLine(g2D,tail.getData(0),
                   tail.getData(1),
                   head.getData(0),
                   head.getData(1));
    }//end draw

  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);

    //Define eight points that define the corners of
    // a box in 3D that is centered on the origin.

    GM01.Point3D[] points = new GM01.Point3D[8];
    //Right side
    points[0] = 
         new GM01.Point3D(new GM01.ColMatrix3D(75,75,75));
    points[1] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,75,-75));
    points[2] = 
       new GM01.Point3D(new GM01.ColMatrix3D(75,-75,-75));
    points[3] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,-75,75));
    //Left side
    points[4] = 
        new GM01.Point3D(new GM01.ColMatrix3D(-75,75,75));
    points[5] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,75,-75));
    points[6] = 
      new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,-75));
    points[7] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,75));

    //Draw seven of the points in BLACK
    g2D.setColor(Color.BLACK);
    for(int cnt = 1;cnt < points.length;cnt++){
      points[cnt].draw(g2D);
    }//end for loop

    //Draw the right top front point in RED to identify
    // it.
    g2D.setColor(Color.RED);
    points[0].draw(g2D);
    g2D.setColor(Color.BLACK);

    //Draw lines that connect the points to define the
    // twelve edges of the box.
    //Right side
    new GM01.Line3D(points[0],points[1]).draw(g2D);
    new GM01.Line3D(points[1],points[2]).draw(g2D);
    new GM01.Line3D(points[2],points[3]).draw(g2D);
    new GM01.Line3D(points[3],points[0]).draw(g2D);

    //Left side
    new GM01.Line3D(points[4],points[5]).draw(g2D);
    new GM01.Line3D(points[5],points[6]).draw(g2D);
    new GM01.Line3D(points[6],points[7]).draw(g2D);
    new GM01.Line3D(points[7],points[4]).draw(g2D);

    //Front
    new GM01.Line3D(points[0],points[4]).draw(g2D);
    new GM01.Line3D(points[3],points[7]).draw(g2D);

    //Back
    new GM01.Line3D(points[1],points[5]).draw(g2D);
    new GM01.Line3D(points[2],points[6]).draw(g2D);

    //Instantiate a vector.
    GM01.Vector3D vecA = new GM01.Vector3D(
                        new GM01.ColMatrix3D(75,-75,-75));

    //Draw the vector with its tail at the upper-left
    // corner of the box. The length and direction of the
    // vector will cause its head to be at the origin.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,points[4]);

  }//end drawOffScreen

  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.Point3D pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(-75,0,0));
    GM01.Point3D pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(75,0,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,-75,0));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,75,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw z-axis in BLUE
    g2D.setColor(Color.BLUE);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,0,-75));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,0,75));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method

  //The purpose of this method is to illustrate vector
  // addition in 3D
  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen image, draw a
    // pair of orthogonal axes on it that intersect at the
    // origin, and paint the background white.
    setCoordinateFrame(g2D);

    //Define two vectors that will be added.
    GM01.Vector3D vecA = new GM01.Vector3D(
                         new GM01.ColMatrix3D(75,75,75));

    GM01.Vector3D vecB = new GM01.Vector3D(
                        new GM01.ColMatrix3D(-15,10,-50));

    //Create a ref point at the origin for convenience.
    GM01.Point3D zeroPoint = new GM01.Point3D(
                             new GM01.ColMatrix3D(0,0,0));

    //Draw vecA in MAGENTA with its tail at the origin.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,zeroPoint);

    //Draw vecB in LIGHT_GRAY with its tail at the head
    // of vecA.
    g2D.setColor(Color.LIGHT_GRAY);
    GM01.Point3D temp = 
                    new GM01.Point3D(vecA.getColMatrix());
    vecB.draw(g2D,temp);

    //Draw vecB in LIGHT_GRAY with its tail at the origin.
    vecB.draw(g2D,zeroPoint);

    //Draw vecA in MAGENTA with its tail at the head
    // of vecB. This completes a trapezoid.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,new GM01.Point3D(vecB.getColMatrix()));

    //Add the two vectors.
    GM01.Vector3D sum = vecA.add(vecB);
    //Draw sum in BLACK with its tail at the origin.
    g2D.setColor(Color.BLACK);
    sum.draw(g2D,zeroPoint);

  }//end drawOffScreen

    public GM01.Point3D scale(GM01.ColMatrix3D scale){
      return new GM01.Point3D(new ColMatrix3D(
                          getData(0) * scale.getData(0),
                          getData(1) * scale.getData(1),
                          getData(2) * scale.getData(2)));
    }//end scale

    public GM01.Point2D rotate(GM01.Point2D anchorPoint,
                               double angle){
      GM01.Point2D newPoint = this.clone();

      double tempX ;
      double tempY;

x2 = x1*cos(alpha) - y1*sin(alpha)
y2 = x1*sin(alpha) + y1*cos(alpha)

      GM01.Vector2D tempVec = 
            new GM01.Vector2D(anchorPoint.getColMatrix());
      newPoint = 
              newPoint.addVectorToPoint(tempVec.negate());

      tempX = newPoint.getData(0);
      tempY = newPoint.getData(1);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(angle*Math.PI/180) -
                      tempY*Math.sin(angle*Math.PI/180));

      newPoint.setData(//new y coordinate
                      1,
                      tempX*Math.sin(angle*Math.PI/180) +
                      tempY*Math.cos(angle*Math.PI/180));

      //Translate back to anchorPoint
      newPoint = newPoint.addVectorToPoint(tempVec);

      return newPoint;

    }//end rotate

  void drawOffScreen(Graphics2D g2D){
    setCoordinateFrame(g2D,false);

    //Create a set of Point2D objects that specify
    // locations on the circumference of a circle that
    // is in the x-y plane with a radius of 50 units. Save
    // references to the Point2D objects in an array.
    for(int cnt = 0;cnt < numberPoints;cnt++){
      points[cnt] = new GM01.Point2D(new GM01.ColMatrix2D(
        50*Math.cos((cnt*360/numberPoints)*Math.PI/180),
        50*Math.sin((cnt*360/numberPoints)*Math.PI/180)));

      //The following object is populated with the 2D 
      // coordinates of the point around which the 
      //rotations will take place.
      GM01.Point2D anchorPoint = new GM01.Point2D(
                            new GM01.ColMatrix2D(
                              xAnchorPoint,yAnchorPoint));
      //Draw the anchorPoint in BLACK.
      g2D.setColor(Color.BLACK);
      anchorPoint.draw(g2D);

      //The following statement causes the rotation to be 
      //performed.
      points[cnt] = 
                 points[cnt].rotate(anchorPoint,rotation);

    }//end for loop

//Code deleted for brevity

  }//end drawOffScreen

Let rotation angle around z-axis be zAngle
Let rotation angle around z-axis be xAngle
Let rotation angle around z-axis be yAngle

Rotation around the z-axis
x2 = x1*cos(zAngle) - y1*sin(zAngle)
y2 = x1*sin(zAngle) + y1*cos(zAngle)

Rotation around the x-axis
y2 = y1*cos(xAngle) - z1*sin(xAngle)
z2 = y1*sin(xAngle) + z1* cos(xAngle) 

Rotation around the y-axis
x2 = x1*cos(yAngle) + z1*sin(yAngle)
z2 = -x1*sin(yAngle) + z1*cos(yAngle)

Where:
  x1, y1, and z1 are cordinates of original point
  x2, y2, and z2 are coordinates of rotated point

    public GM01.Point3D rotate(GM01.Point3D anchorPoint,
                               GM01.ColMatrix3D angles){
      GM01.Point3D newPoint = this.clone();

      double tempX ;
      double tempY;
      double tempZ;
 
      //Translate anchorPoint to the origin
      GM01.Vector3D tempVec = 
            new GM01.Vector3D(anchorPoint.getColMatrix());
      newPoint = 
              newPoint.addVectorToPoint(tempVec.negate());

      double zAngle = angles.getData(0);
      double xAngle = angles.getData(1);
      double yAngle = angles.getData(2);

      //Rotate around z-axis
      tempX = newPoint.getData(0);
      tempY = newPoint.getData(1);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(zAngle*Math.PI/180) -
                      tempY*Math.sin(zAngle*Math.PI/180));

      newPoint.setData(//new y coordinate
                      1,
                      tempX*Math.sin(zAngle*Math.PI/180) +
                      tempY*Math.cos(zAngle*Math.PI/180));

      //Rotate around x-axis
      tempY = newPoint.getData(1);
      tempZ = newPoint.getData(2);
      newPoint.setData(//new y coordinate
                      1,
                      tempY*Math.cos(xAngle*Math.PI/180) -
                      tempZ*Math.sin(xAngle*Math.PI/180));

      newPoint.setData(//new z coordinate
                      2,
                      tempY*Math.sin(xAngle*Math.PI/180) +
                      tempZ*Math.cos(xAngle*Math.PI/180));

      //Rotate around y-axis
      tempX = newPoint.getData(0);
      tempZ = newPoint.getData(2);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(yAngle*Math.PI/180) +
                      tempZ*Math.sin(yAngle*Math.PI/180));

      newPoint.setData(//new z coordinate
                     2,
                     -tempX*Math.sin(yAngle*Math.PI/180) +
                     tempZ*Math.cos(yAngle*Math.PI/180));

      //Translate back to anchorPoint
      newPoint = newPoint.addVectorToPoint(tempVec);

      return newPoint;

    }//end rotate

    for(int cnt = 0;cnt < numberPoints;cnt++){
      points[cnt] = new GM01.Point3D(
        new GM01.ColMatrix3D(
          50*Math.cos((cnt*360/numberPoints)*Math.PI/180),
          50*Math.sin((cnt*360/numberPoints)*Math.PI/180),
          0.0));

      //Populate a ColMatrix3D object with rotation values
      GM01.ColMatrix3D angles = new GM01.ColMatrix3D(
                           zRotation,xRotation,yRotation);

      //Populate a Point3D object with anchor point 
      // coordinates.
      GM01.Point3D anchorPoint = new GM01.Point3D(
               new GM01.ColMatrix3D(
                 xAnchorPoint,yAnchorPoint,zAnchorPoint));
      //Draw the anchorPoint in BLACK.
      g2D.setColor(Color.BLACK);
      anchorPoint.draw(g2D);

      //The following statement causes the rotation to be 
      //performed.
      points[cnt] = 
                   points[cnt].rotate(anchorPoint,angles);

    }//end for loop

/*GM01.java
Copyright 2008, R.G.Baldwin
Revised 02/24/08

This is a major upgrade to the game-math library. This
version upgrades the version named GM2D04 to a new version
named simply GM01.

The primary purpose of the upgrade was to add 3D 
capability for all of the 2D features provided by the
previous version. Because both 2D and 3D capabilities
are included, it is no longer necessary to differentiate
between the two in the name of the class. Therefore, this
version is named GM01.

Adding 3D capability entailed major complexity in one
particular area: drawing the objects. It is difficult to
draw a 3D object on a 2D screen. This requires a 
projection process to project each point in the 3D object
onto the correct location on a 2D plane. There are a 
variety of ways to do this. This 3D library uses an
approach often referred to as an oblique parallel
projection. See the following URL for technical 
information on the projection process:

http://local.wasp.uwa.edu.au/~pbourke/geometry/
classification/


In addition to adding 3D capability, this version also
eliminates the confusion surrounding the fact that the
default direction of the positive y-axis is going down
the screen instead of up the screen as viewers have become
accustomed to. When you use this library, you can program
under the assumption that the positive direction of the
y-axis is up the screen, provided you funnel all of your
drawing tasks through the library and don't draw
directly on the screen.

The name GMnn is an abbreviation for GameMathnn.

See the file named GM2D01.java for a general description 
of the game-math library. The library has been updated
several times. This file is an update of GM2D04.

In addition to the updates mentioned above, this update
cleaned up some lingering areas of code inefficiency,
using the simplest available method to draw on an 
off-screen image. In addition, the following new methods 
were added:

The following methods are new static methods of the class
named GM01. The first method in the list deals with the
problem of displaying a 3D image on a 3D screen.

The last five methods in the list wrap the standard
graphics methods for the purpose of eliminating the issue
of the direction of the positive Y-axis.

GM01.convert3Dto2D
GM01.translate
GM01.drawLine
GM01.fillOval
GM01.drawOval
GM01.fillRect

The following methods are new instance methods of the
indicated static top-level classes belonging to the class
named GM01.

GM01.Vector2D.scale
GM01.Vector2D.negate
GM01.Point2D.clone
GM01.Vector2D.normalize
GM01.Point2D.rotate
GM01.Point2D.scale

GM01.Vector3D.scale
GM01.Vector3D.negate
GM01.Point3D.clone
GM01.Vector3D.normalize
GM01.Point3D.rotate
GM01.Point3D.scale

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.geom.*;
import java.awt.*;

public class GM01{
  //----------------------------------------------------//

  //This method converts a ColMatrix3D object to a
  // ColMatrix2D object. The purpose is to accept
  // x, y, and z coordinate values and transform those
  // values into a pair of coordinate values suitable for
  // display in two dimensions.
  //See http://local.wasp.uwa.edu.au/~pbourke/geometry/
  // classification/ for technical background on the
  // transform from 3D to 2D.
  //The transform equations are:
  // x2d = x3d + z3d * cos(theta)/tan(alpha)
  // y2d = y3d + z3d * sin(theta)/tan(alpha);
  //Let theta = 30 degrees and alpha = 45 degrees
  //Then:cos(theta) = 0.866
  //     sin(theta) = 0.5
  //     tan(alpha) = 1;
  //Note that the signs in the above equations depend
  // on the assumed directions of the angles as well as
  // the assumed positive directions of the axes. The
  // signs used in this method assume the following:
  //   Positive x is to the right.
  //   Positive y is up the screen.
  //   Positive z is protruding out the front of the
  //     screen.
  //   The viewing position is above the x axis and to the
  //     right of the z-y plane.
  public static GM01.ColMatrix2D convert3Dto2D(
                                   GM01.ColMatrix3D data){
    return new GM01.ColMatrix2D(
                  data.getData(0) - 0.866*data.getData(2),
                  data.getData(1) - 0.50*data.getData(2));
  }//end convert3Dto2D 
  //----------------------------------------------------//

  //This method wraps around the translate method of the
  // Graphics2D class. The purpose is to cause the
  // positive direction for the y-axis to be up the screen
  // instead of down the screen. When you use this method,
  // you should program as though the positive direction
  // for the y-axis is up.
  public static void translate(Graphics2D g2D,
                               double xOffset,
                               double yOffset){
    //Flip the sign on the y-coordinate to change the
    // direction of the positive y-axis to go up the
    // screen.
    g2D.translate(xOffset,-yOffset);
  }//end translate
  //----------------------------------------------------//

  //This method wraps around the drawLine method of the
  // Graphics class. The purpose is to cause the positive
  // direction for the y-axis to be up the screen instead
  // of down the screen. When you use this method, you
  // should program as though the positive direction for
  // the y-axis is up.
  public static void drawLine(Graphics2D g2D,
                              double x1,
                              double y1,
                              double x2,
                              double y2){
    //Flip the sign on the y-coordinate value.
    g2D.drawLine((int)x1,-(int)y1,(int)x2,-(int)y2);
  }//end drawLine
  //----------------------------------------------------//

  //This method wraps around the fillOval method of the
  // Graphics class. The purpose is to cause the positive
  // direction for the y-axis to be up the screen instead
  // of down the screen. When you use this method, you
  // should program as though the positive direction for
  // the y-axis is up.
  public static void fillOval(Graphics2D g2D,
                              double x,
                              double y,
                              double width,
                              double height){
    //Flip the sign on the y-coordinate value.
    g2D.fillOval((int)x,-(int)y,(int)width,(int)height);
  }//end fillOval
  //----------------------------------------------------//

  //This method wraps around the drawOval method of the
  // Graphics class. The purpose is to cause the positive
  // direction for the y-axis to be up the screen instead
  // of down the screen. When you use this method, you
  // should program as though the positive direction for
  // the y-axis is up.
  public static void drawOval(Graphics2D g2D,
                              double x,
                              double y,
                              double width,
                              double height){
    //Flip the sign on the y-coordinate value.
    g2D.drawOval((int)x,-(int)y,(int)width,(int)height);
  }//end drawOval
  //----------------------------------------------------//

  //This method wraps around the fillRect method of the
  // Graphics class. The purpose is to cause the positive
  // direction for the y-axis to be up the screen instead
  // of down the screen. When you use this method, you
  // should program as though the positive direction for
  // the y-axis is up.
  public static void fillRect(Graphics2D g2D,
                              double x,
                              double y,
                              double width,
                              double height){
    //Flip the sign on the y-coordinate value.
    g2D.fillRect((int)x,-(int)y,(int)width,(int)height);
  }//end fillRect
  //----------------------------------------------------//



  //An object of this class represents a 2D column matrix.
  // An object of this class is the fundamental building
  // block for several of the other classes in the
  // library.
  public static class ColMatrix2D{
    double[] data = new double[2];

    public ColMatrix2D(double data0,double data1){
      data[0] = data0;
      data[1] = data1;
    }//end constructor
    //--------------------------------------------------//

    //Overridden toString method.
    public String toString(){
      return data[0] + "," + data[1];
    }//end overridden toString method
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return data[index];
      }//end else
    }//end getData method
    //--------------------------------------------------//
    
    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        this.data[index] = data;
      }//end else
    }//end setData method
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in two matrices and returns true if the
    // values are equal or almost equal and returns false
    // otherwise. 
    public boolean equals(Object obj){
      if(obj instanceof GM01.ColMatrix2D &&
         Math.abs(((GM01.ColMatrix2D)obj).getData(0) - 
                                 getData(0)) <= 0.00001 &&
         Math.abs(((GM01.ColMatrix2D)obj).getData(1) - 
                                  getData(1)) <= 0.00001){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//

    //Adds one ColMatrix2D object to another ColMatrix2D
    // object, returning a ColMatrix2D object.
    public GM01.ColMatrix2D add(GM01.ColMatrix2D matrix){
      return new GM01.ColMatrix2D(
                            getData(0)+matrix.getData(0),
                            getData(1)+matrix.getData(1));
    }//end add
    //--------------------------------------------------//

    //Subtracts one ColMatrix2D object from another
    // ColMatrix2D object, returning a ColMatrix2D object.
    // The object that is received as an incoming
    // parameter  is subtracted from the object on which
    // the method is called.
    public GM01.ColMatrix2D subtract(
                                 GM01.ColMatrix2D matrix){
      return new GM01.ColMatrix2D(
                            getData(0)-matrix.getData(0),
                            getData(1)-matrix.getData(1));
    }//end subtract
    //--------------------------------------------------//
  }//end class ColMatrix2D
  //====================================================//


  //An object of this class represents a 3D column matrix.
  // An object of this class is the fundamental building
  // block for several of the other classes in the
  // library.
  public static class ColMatrix3D{
    double[] data = new double[3];

    public ColMatrix3D(
                  double data0,double data1,double data2){
      data[0] = data0;
      data[1] = data1;
      data[2] = data2;
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return data[0] + "," + data[1] + "," + data[2];
    }//end overridden toString method
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 2)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return data[index];
      }//end else
    }//end getData method
    //--------------------------------------------------//

    public void setData(int index,double data){
      if((index < 0) || (index > 2)){ 
        throw new IndexOutOfBoundsException();
      }else{
        this.data[index] = data;
      }//end else
    }//end setData method
    //--------------------------------------------------//
    
    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in two matrices and returns true if the
    // values are equal or almost equal and returns false
    // otherwise.
    public boolean equals(Object obj){
      if(obj instanceof GM01.ColMatrix3D &&
         Math.abs(((GM01.ColMatrix3D)obj).getData(0) - 
                                 getData(0)) <= 0.00001 &&
         Math.abs(((GM01.ColMatrix3D)obj).getData(1) - 
                                 getData(1)) <= 0.00001 &&
         Math.abs(((GM01.ColMatrix3D)obj).getData(2) - 
                                  getData(2)) <= 0.00001){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//

    //Adds one ColMatrix3D object to another ColMatrix3D
    // object, returning a ColMatrix3D object.
    public GM01.ColMatrix3D add(GM01.ColMatrix3D matrix){
      return new GM01.ColMatrix3D(
                            getData(0)+matrix.getData(0),
                            getData(1)+matrix.getData(1),
                            getData(2)+matrix.getData(2));
    }//end add
    //--------------------------------------------------//

    //Subtracts one ColMatrix3D object from another
    // ColMatrix3D object, returning a ColMatrix3D object.
    // The object that is received as an incoming
    // parameter is subtracted from the object on which
    // the method is called.
    public GM01.ColMatrix3D subtract(
                                 GM01.ColMatrix3D matrix){
      return new GM01.ColMatrix3D(
                            getData(0)-matrix.getData(0),
                            getData(1)-matrix.getData(1),
                            getData(2)-matrix.getData(2));
    }//end subtract
    //--------------------------------------------------//
  }//end class ColMatrix3D
  //====================================================//
  //====================================================//


  public static class Point2D{
    GM01.ColMatrix2D point;
    
    public Point2D(GM01.ColMatrix2D point){//constructor
      //Create and save a clone of the ColMatrix2D object
      // used to define the point to prevent the point
      // from being corrupted by a later change in the
      // values stored in the original ColMatrix2D object
      // through use of its set method.
      this.point = new ColMatrix2D(
                       point.getData(0),point.getData(1));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return point.getData(0) + "," + point.getData(1);
    }//end toString
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return point.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//

    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        point.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//

    //This method draws a small circle around the location
    // of the point on the specified graphics context.
    public void draw(Graphics2D g2D){
      drawOval(g2D,getData(0)-3,
                   getData(1)+3,6,6);
    }//end draw

    //--------------------------------------------------//

    //Returns a reference to the ColMatrix2D object that
    // defines this Point2D object.
    public GM01.ColMatrix2D getColMatrix(){
      return point;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix2D objects that define two
    // Point2D objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(point.equals(((GM01.Point2D)obj).
                                         getColMatrix())){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//

    //Gets a displacement vector from one Point2D object
    // to a second Point2D object. The vector points from
    // the object on which the method is called to the
    // object passed as a parameter to the method. Kjell
    // describes this as the distance you would have to
    // walk along the x and then the y axes to get from
    // the first point to the second point.
    public GM01.Vector2D getDisplacementVector(
                                      GM01.Point2D point){
      return new GM01.Vector2D(new GM01.ColMatrix2D(
                            point.getData(0)-getData(0),
                            point.getData(1)-getData(1)));
    }//end getDisplacementVector
    //--------------------------------------------------//

    //Adds a Vector2D to a Point2D producing a
    // new Point2D.
    public GM01.Point2D addVectorToPoint(
                                      GM01.Vector2D vec){
      return new GM01.Point2D(new GM01.ColMatrix2D(
                          getData(0) + vec.getData(0),
                          getData(1) + vec.getData(1)));
    }//end addVectorToPoint
    //--------------------------------------------------//

    //Returns a new Point2D object that is a clone of
    // the object on which the method is called.
    public Point2D clone(){
      return new Point2D(
                  new ColMatrix2D(getData(0),getData(1)));
    }//end clone
    //--------------------------------------------------//

    //The purpose of this method is to rotate a point
    // around a specified anchor point in the x-y plane.
    //The rotation angle is passed in as a double value
    // in degrees with the positive angle of rotation
    // being counter-clockwise.
    //This method does not modify the contents of the
    // Point2D object on which the method is called.
    // Rather, it uses the contents of that object to
    // instantiate, rotate, and return a new Point2D
    // object.
    //For simplicity, this method translates the
    // anchorPoint to the origin, rotates around the
    // origin, and then translates back to the
    // anchorPoint.
    /*
    See http://www.ia.hiof.no/~borres/cgraph/math/threed/
    p-threed.html for a definition of the equations
    required to do the rotation.

    x2 = x1*cos - y1*sin
    y2 = x1*sin + y1*cos
    */ 
    public GM01.Point2D rotate(GM01.Point2D anchorPoint,
                               double angle){
      GM01.Point2D newPoint = this.clone();

      double tempX ;
      double tempY;
 
      //Translate anchorPoint to the origin
      GM01.Vector2D tempVec = 
            new GM01.Vector2D(anchorPoint.getColMatrix());
      newPoint = 
              newPoint.addVectorToPoint(tempVec.negate());

      //Rotate around the origin.
      tempX = newPoint.getData(0);
      tempY = newPoint.getData(1);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(angle*Math.PI/180) -
                      tempY*Math.sin(angle*Math.PI/180));

      newPoint.setData(//new y coordinate
                      1,
                      tempX*Math.sin(angle*Math.PI/180) +
                      tempY*Math.cos(angle*Math.PI/180));

      //Translate back to anchorPoint
      newPoint = newPoint.addVectorToPoint(tempVec);
      
      return newPoint;

    }//end rotate
    //--------------------------------------------------//

    //Multiplies this point by a scaling matrix received
    // as an incoming parameter and returns the scaled
    // point.
    public GM01.Point2D scale(GM01.ColMatrix2D scale){
      return new GM01.Point2D(new ColMatrix2D(
                          getData(0) * scale.getData(0),
                          getData(1) * scale.getData(1)));
    }//end scale
    //--------------------------------------------------//
  }//end class Point2D
  //====================================================//


  public static class Point3D{
    GM01.ColMatrix3D point;

    public Point3D(GM01.ColMatrix3D point){//constructor
      //Create and save a clone of the ColMatrix3D object
      // used to define the point to prevent the point
      // from being corrupted by a later change in the
      // values stored in the original ColMatrix3D object
      // through use of its set method.
      this.point = 
         new ColMatrix3D(point.getData(0),
                         point.getData(1),
                         point.getData(2));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return point.getData(0) + "," + point.getData(1) 
                                 + "," + point.getData(2);
    }//end toString
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 2)){ 
        throw new IndexOutOfBoundsException();
      }else{
        return point.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//

    public void setData(int index,double data){
      if((index < 0) || (index > 2)){ 
        throw new IndexOutOfBoundsException();
      }else{
        point.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//

    //This method draws a small circle around the location
    // of the point on the specified graphics context.
    public void draw(Graphics2D g2D){

      //Get 2D projection coordinate values.
      ColMatrix2D temp = convert3Dto2D(point);
      drawOval(g2D,temp.getData(0)-3,
                   temp.getData(1)+3,
                   6,
                   6);
    }//end draw
    //--------------------------------------------------//

    //Returns a reference to the ColMatrix3D object that
    // defines this Point3D object.
    public GM01.ColMatrix3D getColMatrix(){
      return point;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix3D objects that define two
    // Point3D objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(point.equals(((GM01.Point3D)obj).
                                         getColMatrix())){
        return true;
      }else{
        return false;
      }//end else

    }//end overridden equals method
    //--------------------------------------------------//

    //Gets a displacement vector from one Point3D object
    // to a second Point3D object. The vector points from
    // the object on which the method is called to the
    // object passed as a parameter to the method. Kjell
    // describes this as the distance you would have to
    // walk along the x and then the y axes to get from
    // the first point to the second point.
    public GM01.Vector3D getDisplacementVector(
                                      GM01.Point3D point){
      return new GM01.Vector3D(new GM01.ColMatrix3D(
                            point.getData(0)-getData(0),
                            point.getData(1)-getData(1),
                            point.getData(2)-getData(2)));
    }//end getDisplacementVector
    //--------------------------------------------------//

    //Adds a Vector3D to a Point3D producing a
    // new Point3D.
    public GM01.Point3D addVectorToPoint(
                                      GM01.Vector3D vec){
      return new GM01.Point3D(new GM01.ColMatrix3D(
                          getData(0) + vec.getData(0),
                          getData(1) + vec.getData(1),
                          getData(2) + vec.getData(2)));
    }//end addVectorToPoint
    //--------------------------------------------------//

    //Returns a new Point3D object that is a clone of
    // the object on which the method is called.
    public Point3D clone(){
      return new Point3D(new ColMatrix3D(getData(0),
                                         getData(1),
                                         getData(2)));
    }//end clone
    //--------------------------------------------------//

    //The purpose of this method is to rotate a point
    // around a specified anchor point in the following
    // order:
    // Rotate around z - rotation in x-y plane.
    // Rotate around x - rotation in y-z plane.
    // Rotate around y - rotation in x-z plane.
    //The rotation angles are passed in as double values
    // in degrees (based on the right-hand rule) in the
    // order given above, packaged in an object of the
    // class GM01.ColMatrix3D. (Note that in this case,
    // the ColMatrix3D object is simply a convenient
    // container and it has no significance from a matrix
    // viewpoint.)
    //The right-hand rule states that if you point the
    // thumb of your right hand in the positive direction
    // of an axis, the direction of positive rotation
    // around that axis is given by the direction that
    // your fingers will be pointing.
    //This method does not modify the contents of the
    // Point3D object on which the method is called.
    // Rather, it uses the contents of that object to
    // instantiate, rotate, and return a new Point3D
    // object.
    //For simplicity, this method translates the
    // anchorPoint to the origin, rotates around the
    // origin, and then translates back to the
    // anchorPoint.
    /*
    See http://www.ia.hiof.no/~borres/cgraph/math/threed/
    p-threed.html for a definition of the equations
    required to do the rotation.
    z-axis 
    x2 = x1*cos - y1*sin
    y2 = x1*sin + y1*cos

    x-axis
    y2 = y1*cos(v) - z1*sin(v)
    z2 = y1*sin(v) + z1* cos(v) 

    y-axis
    x2 = x1*cos(v) + z1*sin(v)
    z2 = -x1*sin(v) + z1*cos(v)
    */ 
    public GM01.Point3D rotate(GM01.Point3D anchorPoint,
                               GM01.ColMatrix3D angles){
      GM01.Point3D newPoint = this.clone();

      double tempX ;
      double tempY;
      double tempZ;

      //Translate anchorPoint to the origin
      GM01.Vector3D tempVec = 
            new GM01.Vector3D(anchorPoint.getColMatrix());
      newPoint = 
              newPoint.addVectorToPoint(tempVec.negate());

      double zAngle = angles.getData(0);
      double xAngle = angles.getData(1);
      double yAngle = angles.getData(2);

      //Rotate around z-axis
      tempX = newPoint.getData(0);
      tempY = newPoint.getData(1);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(zAngle*Math.PI/180) -
                      tempY*Math.sin(zAngle*Math.PI/180));

      newPoint.setData(//new y coordinate
                      1,
                      tempX*Math.sin(zAngle*Math.PI/180) +
                      tempY*Math.cos(zAngle*Math.PI/180));

      //Rotate around x-axis
      tempY = newPoint.getData(1);
      tempZ = newPoint.getData(2);
      newPoint.setData(//new y coordinate
                      1,
                      tempY*Math.cos(xAngle*Math.PI/180) -
                      tempZ*Math.sin(xAngle*Math.PI/180));

      newPoint.setData(//new z coordinate
                      2,
                      tempY*Math.sin(xAngle*Math.PI/180) +
                      tempZ*Math.cos(xAngle*Math.PI/180));

      //Rotate around y-axis
      tempX = newPoint.getData(0);
      tempZ = newPoint.getData(2);
      newPoint.setData(//new x coordinate
                      0,
                      tempX*Math.cos(yAngle*Math.PI/180) +
                      tempZ*Math.sin(yAngle*Math.PI/180));

      newPoint.setData(//new z coordinate
                     2,
                     -tempX*Math.sin(yAngle*Math.PI/180) +
                     tempZ*Math.cos(yAngle*Math.PI/180));

      //Translate back to anchorPoint
      newPoint = newPoint.addVectorToPoint(tempVec);

      return newPoint;

    }//end rotate
    //--------------------------------------------------//

    //Multiplies this point by a scaling matrix received
    // as an incoming parameter and returns the scaled
    // point.
    public GM01.Point3D scale(GM01.ColMatrix3D scale){
      return new GM01.Point3D(new ColMatrix3D(
                          getData(0) * scale.getData(0),
                          getData(1) * scale.getData(1),
                          getData(2) * scale.getData(2)));
    }//end scale
    //--------------------------------------------------//
  }//end class Point3D
  //====================================================//
  //====================================================//


  public static class Vector2D{
    GM01.ColMatrix2D vector;
    
    public Vector2D(GM01.ColMatrix2D vector){//constructor
      //Create and save a clone of the ColMatrix2D object
      // used to define the vector to prevent the vector
      // from being corrupted by a later change in the
      // values stored in the original ColVector2D object.
      this.vector = new ColMatrix2D(
                     vector.getData(0),vector.getData(1));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return vector.getData(0) + "," + vector.getData(1);
    }//end toString
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 1)){
        throw new IndexOutOfBoundsException();
      }else{
        return vector.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//

    public void setData(int index,double data){
      if((index < 0) || (index > 1)){ 
        throw new IndexOutOfBoundsException();
      }else{
        vector.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//

    //This method draws a vector on the specified graphics
    // context, with the tail of the vector located at a
    // specified point, and with a small filled circle at
    // the head.
    public void draw(Graphics2D g2D,GM01.Point2D tail){

      drawLine(g2D,
               tail.getData(0),
               tail.getData(1),
               tail.getData(0)+vector.getData(0),
               tail.getData(1)+vector.getData(1));

      fillOval(g2D,
               tail.getData(0)+vector.getData(0)-3,
               tail.getData(1)+vector.getData(1)+3,
               6,
               6);
    }//end draw
    //--------------------------------------------------//

    //Returns a reference to the ColMatrix2D object that
    // defines this Vector2D object.
    public GM01.ColMatrix2D getColMatrix(){
      return vector;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix2D objects that define two
    // Vector2D objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(vector.equals((
                     (GM01.Vector2D)obj).getColMatrix())){
        return true;
      }else{
        return false;
      }//end else

    }//end overridden equals method
    //--------------------------------------------------//

    //Adds this vector to a vector received as an incoming
    // parameter and returns the sum as a vector.
    public GM01.Vector2D add(GM01.Vector2D vec){
      return new GM01.Vector2D(new ColMatrix2D(
                       vec.getData(0)+vector.getData(0),
                       vec.getData(1)+vector.getData(1)));
    }//end add
    //--------------------------------------------------//

    //Returns the length of a Vector2D object.
    public double getLength(){
      return Math.sqrt(
           getData(0)*getData(0) + getData(1)*getData(1));
    }//end getLength
    //--------------------------------------------------//

    //Multiplies this vector by a scale factor received as
    // an incoming parameter and returns the scaled
    // vector.
    public GM01.Vector2D scale(Double factor){
      return new GM01.Vector2D(new ColMatrix2D(
                                    getData(0) * factor,
                                    getData(1) * factor));
    }//end scale
    //--------------------------------------------------//

    //Changes the sign on each of the vector components
    // and returns the negated vector.
    public GM01.Vector2D negate(){
      return new GM01.Vector2D(new ColMatrix2D(
                                            -getData(0),
                                            -getData(1)));
    }//end negate
    //--------------------------------------------------//

    //Returns a new vector that points in the same
    // direction but has a length of one unit.
    public GM01.Vector2D normalize(){
      double length = getLength();
      return new GM01.Vector2D(new ColMatrix2D(
                                      getData(0)/length,
                                      getData(1)/length));
    }//end normalize
    //--------------------------------------------------//
  }//end class Vector2D
  //====================================================//


  public static class Vector3D{
    GM01.ColMatrix3D vector;

    public Vector3D(GM01.ColMatrix3D vector){//constructor
      //Create and save a clone of the ColMatrix3D object
      // used to define the vector to prevent the vector
      // from being corrupted by a later change in the
      // values stored in the original ColMatris3D object.
      this.vector = new ColMatrix3D(vector.getData(0),
                                    vector.getData(1),
                                    vector.getData(2));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return vector.getData(0) + "," + vector.getData(1) 
                                + "," + vector.getData(2);
    }//end toString
    //--------------------------------------------------//

    public double getData(int index){
      if((index < 0) || (index > 2)){
        throw new IndexOutOfBoundsException();
      }else{
        return vector.getData(index);
      }//end else
    }//end getData
    //--------------------------------------------------//

    public void setData(int index,double data){
      if((index < 0) || (index > 2)){ 
        throw new IndexOutOfBoundsException();
      }else{
        vector.setData(index,data);
      }//end else
    }//end setData
    //--------------------------------------------------//

    //This method draws a vector on the specified graphics
    // context, with the tail of the vector located at a
    // specified point, and with a small circle at the
    // head.
    public void draw(Graphics2D g2D,GM01.Point3D tail){

      //Get a 2D projection of the tail
      GM01.ColMatrix2D tail2D = convert3Dto2D(tail.point);

      //Get the 3D location of the head
      GM01.ColMatrix3D head = 
                      tail.point.add(this.getColMatrix());

      //Get a 2D projection of the head
      GM01.ColMatrix2D head2D = convert3Dto2D(head);
      drawLine(g2D,tail2D.getData(0),
                   tail2D.getData(1),
                   head2D.getData(0),
                   head2D.getData(1));

      //Draw a small filled circle to identify the head.
      fillOval(g2D,head2D.getData(0)-3,
                   head2D.getData(1)+3,
                   6,
                   6);

    }//end draw
    //--------------------------------------------------//

    //Returns a reference to the ColMatrix3D object that
    // defines this Vector3D object.
    public GM01.ColMatrix3D getColMatrix(){
      return vector;
    }//end getColMatrix
    //--------------------------------------------------//

    //This method overrides the equals method inherited
    // from the class named Object. It compares the values
    // stored in the ColMatrix3D objects that define two
    // Vector3D objects and returns true if they are equal
    // and false otherwise. 
    public boolean equals(Object obj){
      if(vector.equals((
                     (GM01.Vector3D)obj).getColMatrix())){
        return true;
      }else{
        return false;
      }//end else
     
    }//end overridden equals method
    //--------------------------------------------------//
    
    //Adds this vector to a vector received as an incoming
    // parameter and returns the sum as a vector.
    public GM01.Vector3D add(GM01.Vector3D vec){
      return new GM01.Vector3D(new ColMatrix3D(
                       vec.getData(0)+vector.getData(0),
                       vec.getData(1)+vector.getData(1),
                       vec.getData(2)+vector.getData(2)));
    }//end add
    //--------------------------------------------------//

    //Returns the length of a Vector3D object.
    public double getLength(){
      return Math.sqrt(getData(0)*getData(0) + 
                       getData(1)*getData(1) + 
                       getData(2)*getData(2));
    }//end getLength
    //--------------------------------------------------//

    //Multiplies this vector by a scale factor received as
    // an incoming parameter and returns the scaled
    // vector.
    public GM01.Vector3D scale(Double factor){
      return new GM01.Vector3D(new ColMatrix3D(
                                    getData(0) * factor,
                                    getData(1) * factor,
                                    getData(2) * factor));
    }//end scale
    //--------------------------------------------------//

    //Changes the sign on each of the vector components
    // and returns the negated vector.
    public GM01.Vector3D negate(){
      return new GM01.Vector3D(new ColMatrix3D(
                                            -getData(0),
                                            -getData(1),
                                            -getData(2)));
    }//end negate
    //--------------------------------------------------//

    //Returns a new vector that points in the same
    // direction but has a length of one unit.
    public GM01.Vector3D normalize(){
      double length = getLength();
      return new GM01.Vector3D(new ColMatrix3D(
                                      getData(0)/length,
                                      getData(1)/length,
                                      getData(2)/length));
    }//end normalize
    //--------------------------------------------------//
  }//end class Vector3D
  //====================================================//
  //====================================================//


  //A line is defined by two points. One is called the
  // tail and the other is called the head. Note that this
  // class has the same name as one of the classes in
  // the Graphics2D class. Therefore, if the class from
  // the Graphics2D class is used in some future upgrade
  // to this program, it will have to be fully qualified.
  public static class Line2D{
    GM01.Point2D[] line = new GM01.Point2D[2];
    
    public Line2D(GM01.Point2D tail,GM01.Point2D head){
      //Create and save clones of the points used to
      // define the line to prevent the line from being 
      // corrupted by a later change in the coordinate
      // values of the points.
      this.line[0] = new Point2D(new GM01.ColMatrix2D(
                        tail.getData(0),tail.getData(1)));
      this.line[1] = new Point2D(new GM01.ColMatrix2D(
                        head.getData(0),head.getData(1)));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return "Tail = " + line[0].getData(0) + "," 
             + line[0].getData(1) + "nHead = " 
             + line[1].getData(0) + "," 
             + line[1].getData(1);
    }//end toString
    //--------------------------------------------------//

    public GM01.Point2D getTail(){
      return line[0];
    }//end getTail
    //--------------------------------------------------//

    public GM01.Point2D getHead(){
      return line[1];
    }//end getHead
    //--------------------------------------------------//

    public void setTail(GM01.Point2D newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[0] = new Point2D(new GM01.ColMatrix2D(
                newPoint.getData(0),newPoint.getData(1)));
    }//end setTail
    //--------------------------------------------------//

    public void setHead(GM01.Point2D newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[1] = new Point2D(new GM01.ColMatrix2D(
                newPoint.getData(0),newPoint.getData(1)));
    }//end setHead
    //--------------------------------------------------//

    public void draw(Graphics2D g2D){
      drawLine(g2D,getTail().getData(0),
                   getTail().getData(1),
                   getHead().getData(0),
                   getHead().getData(1));
    }//end draw
    //--------------------------------------------------//
  }//end class Line2D
  //====================================================//


  //A line is defined by two points. One is called the
  // tail and the other is called the head.
  public static class Line3D{
    GM01.Point3D[] line = new GM01.Point3D[2];

    public Line3D(GM01.Point3D tail,GM01.Point3D head){
      //Create and save clones of the points used to
      // define the line to prevent the line from being 
      // corrupted by a later change in the coordinate
      // values of the points.
      this.line[0] = new Point3D(new GM01.ColMatrix3D(
                                        tail.getData(0),
                                        tail.getData(1),
                                        tail.getData(2)));
      this.line[1] = new Point3D(new GM01.ColMatrix3D(
                                        head.getData(0),
                                        head.getData(1),
                                        head.getData(2)));
    }//end constructor
    //--------------------------------------------------//

    public String toString(){
      return "Tail = " + line[0].getData(0) + "," 
                       + line[0].getData(1)  + "," 
                       + line[0].getData(2) 
                       + "nHead = " 
                       + line[1].getData(0) + "," 
                       + line[1].getData(1) + ","      
                       + line[1].getData(2);
    }//end toString
    //--------------------------------------------------//

    public GM01.Point3D getTail(){
      return line[0];
    }//end getTail
    //--------------------------------------------------//

    public GM01.Point3D getHead(){
      return line[1];
    }//end getHead
    //--------------------------------------------------//

    public void setTail(GM01.Point3D newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[0] = new Point3D(new GM01.ColMatrix3D(
                                    newPoint.getData(0),
                                    newPoint.getData(1),
                                    newPoint.getData(2)));
    }//end setTail
    //--------------------------------------------------//

    public void setHead(GM01.Point3D newPoint){
      //Create and save a clone of the new point to
      // prevent the line from being corrupted by a
      // later change in the coordinate values of the
      // point.
      this.line[1] = new Point3D(new GM01.ColMatrix3D(
                                    newPoint.getData(0),
                                    newPoint.getData(1),
                                    newPoint.getData(2)));
    }//end setHead
    //--------------------------------------------------//

    public void draw(Graphics2D g2D){

      //Get 2D projection coordinates.
      GM01.ColMatrix2D tail = 
                           convert3Dto2D(getTail().point);
      GM01.ColMatrix2D head = 
                           convert3Dto2D(getHead().point);

      drawLine(g2D,tail.getData(0),
                   tail.getData(1),
                   head.getData(0),
                   head.getData(1));
    }//end draw
    //--------------------------------------------------//
  }//end class Line3D
  //====================================================//

}//end class GM01
//======================================================//

/*GM01test02.java
Copyright 2008, R.G.Baldwin
Revised 02/18/08

This program tests many 2D aspects of the GM01 library
using both text and graphics.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;

class GM01test02{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class GM01test02
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 400;
  int vSize = 400;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas

  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());

    //Perform tests using text.
    testUsingText();

    //Perform tests using graphics.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//

  //The purpose of this method is to test various
  // 2D aspects of the library using text.
  public void testUsingText(){
    System.out.println(
               "Test overridden toString of ColMatrix2D");
    GM01.ColMatrix2D tempA = 
                            new GM01.ColMatrix2D(1.5,2.5);
    System.out.println(tempA);
    System.out.println();

    System.out.println(
               "Test setData and getData of ColMatrix2D");
    tempA.setData(0,4.5);
    System.out.println(tempA.getData(0));
    tempA.setData(1,5.5);
    System.out.println(tempA.getData(1));
    System.out.println();

    System.out.println(
                     "Test equals method of ColMatrix2D");
    GM01.ColMatrix2D tempB = 
                            new GM01.ColMatrix2D(1.5,2.5);
    System.out.println(tempA.equals(tempB));
    tempB.setData(0,4.5);
    tempB.setData(1,5.5);
    System.out.println(tempA.equals(tempB));
    System.out.println();

    System.out.println("Test add method of ColMatrix2D");
    System.out.println(tempA.add(tempB));
    System.out.println();

    System.out.println(
                   "Test subtract method of ColMatrix2D");
    System.out.println(tempA.subtract(tempB));
    System.out.println();

    System.out.println("Test toString method of Point2D");
    GM01.Point2D pointA = new GM01.Point2D(tempA);
    System.out.println(pointA);
    System.out.println();

    System.out.println(
                   "Test setData and getData of Point2D");
    pointA.setData(0,1.1);
    System.out.println(pointA.getData(0));
    pointA.setData(1,2.2);
    System.out.println(pointA.getData(1));
    System.out.println();

    System.out.println(
                   "Test getColMatrix method of Point2D");
    System.out.println(pointA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Point2D");
    GM01.Point2D pointB = new GM01.Point2D(tempB);
    System.out.println(pointA.equals(pointB));
    pointA = new GM01.Point2D(tempB);
    System.out.println(pointA.equals(pointB));
    System.out.println();

    System.out.println(
          "Test getDisplacementVector method of Point2D");
    pointA = 
          new GM01.Point2D(new GM01.ColMatrix2D(1.5,2.5));
    System.out.println(pointA);
    System.out.println(pointB);
    System.out.println(
                    pointA.getDisplacementVector(pointB));
    System.out.println();

    System.out.println(
               "Test addVectorToPoint method of Point2D");
    System.out.println(pointA);
    System.out.println(pointA.addVectorToPoint(
      new GM01.Vector2D(new GM01.ColMatrix2D(5.5,6.5))));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Point2D class.

    System.out.println(
                      "Test toString method of Vector2D");
    GM01.Vector2D vecA = 
         new GM01.Vector2D(new GM01.ColMatrix2D(1.5,2.5));
    System.out.println(vecA);
    System.out.println();

    System.out.println(
          "Test setData and getData methods of Vector2D");
    vecA.setData(0,4.5);
    System.out.println(vecA.getData(0));
    vecA.setData(1,5.5);
    System.out.println(vecA.getData(1));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Vector2D class.

    System.out.println(
                  "Test getColMatrix method of Vector2D");
    System.out.println(vecA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Vector2D");
    GM01.Vector2D vecB = 
         new GM01.Vector2D(new GM01.ColMatrix2D(1.5,2.5));
    System.out.println(vecA.equals(vecB));
    vecB.setData(0,4.5);
    vecB.setData(1,5.5);
    System.out.println(vecA.equals(vecB));

    System.out.println("Test add method of Vector2D");
    System.out.println(vecA);
    vecB = 
        new GM01.Vector2D(new GM01.ColMatrix2D(-1.5,3.5));
    System.out.println(vecB);
    System.out.println(vecA.add(vecB));
    System.out.println();


    System.out.println(
                     "Test getLength method of Vector2D");
    vecA = 
         new GM01.Vector2D(new GM01.ColMatrix2D(3.0,4.0));
    System.out.println(vecA);
    System.out.println(vecA.getLength());
    System.out.println();

    System.out.println("Test toString method of Line2D");
    GM01.Line2D lineA = new GM01.Line2D(pointA,pointB);
    System.out.println(lineA);
    System.out.println();

    System.out.println("Test setTail, setHead, getTail, "
                     + "nand getHead methods of Line2D");
    lineA.setTail(pointB);
    lineA.setHead(pointA);
    System.out.println(lineA.getTail());
    System.out.println(lineA.getHead());
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Line2D class.
    
  }//end testUsingText
  //----------------------------------------------------//

  //The purpose of this method is test various 2D aspects
  // of the game-math library using graphics.
  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);

    //Define the corners of a square in 2D that is
    // centered on the origin.
    GM01.Point2D pointA = 
           new GM01.Point2D(new GM01.ColMatrix2D(75,-75));
    GM01.Point2D pointB = 
          new GM01.Point2D(new GM01.ColMatrix2D(-75,-75));
    GM01.Point2D pointC = 
           new GM01.Point2D(new GM01.ColMatrix2D(-75,75));
    GM01.Point2D pointD = 
            new GM01.Point2D(new GM01.ColMatrix2D(75,75));

    //Draw three of the points in BLACK. Draw the fourth
    // point in RED to identify it.
    g2D.setColor(Color.BLACK);
    pointA.draw(g2D);
    pointB.draw(g2D);
    pointC.draw(g2D);
    g2D.setColor(Color.RED);
    pointD.draw(g2D);
    g2D.setColor(Color.BLACK);


    //Draw four lines connecting the points to produce
    // the outline of a square.
    GM01.Line2D lineAB = new GM01.Line2D(pointA,pointB);
    lineAB.draw(g2D);

    GM01.Line2D lineBC = new GM01.Line2D(pointB,pointC);
    lineBC.draw(g2D);

    GM01.Line2D lineCD = new GM01.Line2D(pointC,pointD);
    lineCD.draw(g2D);

    GM01.Line2D lineDA = new GM01.Line2D(pointD,pointA);
    lineDA.draw(g2D);

    //Define a vector.
    GM01.Vector2D vecA = new GM01.Vector2D(
                            new GM01.ColMatrix2D(75,75));

    //Draw the vector with its tail at pointB. The length
    // and direction of the vector will cause its head
    // to be at the origin.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,pointB);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image and to draw orthogonal 2D axes on
  // the image that intersect at the origin.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.drawLine(g2D,-75,0,75,0);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    GM01.drawLine(g2D,0,75,0,-75);

  }//end setCoordinateFrame method
  //====================================================//


  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas

}//end class GUI
//======================================================//

/*GM01test01.java 
Copyright 2008, R.G.Baldwin
Revised 02/18/08

This program tests many 3D aspects of the GM01 library
using both text and graphics.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;

class GM01test01{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class GM01test01
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 400;
  int vSize = 400;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas

  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());

    //Test many 3D library features using text.
    testUsingText();

    //Test many 3D library features using graphics.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//

    //The purpose of this method is to test various
    // 3D aspects of the library using text.
  public void testUsingText(){
    System.out.println(
               "Test overridden toString of ColMatrix3D");
    GM01.ColMatrix3D tempA = 
                        new GM01.ColMatrix3D(1.5,2.5,3.5);
    System.out.println(tempA);
    System.out.println();

    System.out.println(
               "Test setData and getData of ColMatrix3D");
    tempA.setData(0,4.5);
    System.out.println(tempA.getData(0));
    tempA.setData(1,5.5);
    System.out.println(tempA.getData(1));
    tempA.setData(2,6.5);
    System.out.println(tempA.getData(2));
    System.out.println();

    System.out.println(
                     "Test equals method of ColMatrix3D");
    GM01.ColMatrix3D tempB = 
                        new GM01.ColMatrix3D(1.5,2.5,3.5);
    System.out.println(tempA.equals(tempB));
    tempB.setData(0,4.5);
    tempB.setData(1,5.5);
    tempB.setData(2,6.5);
    System.out.println(tempA.equals(tempB));
    System.out.println();

    System.out.println("Test add method of ColMatrix3D");
    System.out.println(tempA.add(tempB));
    System.out.println();

    System.out.println(
                   "Test subtract method of ColMatrix3D");
    System.out.println(tempA.subtract(tempB));
    System.out.println();

    System.out.println("Test toString method of Point3D");
    GM01.Point3D pointA = new GM01.Point3D(tempA);
    System.out.println(pointA);
    System.out.println();

    System.out.println(
                   "Test setData and getData of Point3D");
    pointA.setData(0,1.1);
    System.out.println(pointA.getData(0));
    pointA.setData(1,2.2);
    System.out.println(pointA.getData(1));
    pointA.setData(2,3.3);
    System.out.println(pointA.getData(2));
    System.out.println();

    System.out.println("Test getColMatrix of Point3D");
    System.out.println(pointA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Point3D");
    GM01.Point3D pointB = new GM01.Point3D(tempB);
    System.out.println(pointA.equals(pointB));
    pointA = new GM01.Point3D(tempB);
    System.out.println(pointA.equals(pointB));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Point3D class.

    System.out.println(
          "Test getDisplacementVector method of Point3D");
    pointA = 
      new GM01.Point3D(new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(pointA);
    System.out.println(pointB);
    System.out.println(
                    pointA.getDisplacementVector(pointB));
    System.out.println();

    System.out.println(
               "Test addVectorToPoint method of Point3D");
    System.out.println(pointA);
    System.out.println(pointA.addVectorToPoint(
                   new GM01.Vector3D(
                     new GM01.ColMatrix3D(5.5,6.5,7.5))));
    System.out.println();

    System.out.println(
                      "Test toString method of Vector3D");
    GM01.Vector3D vecA = new GM01.Vector3D(
                       new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(vecA);
    System.out.println();

    System.out.println(
          "Test setData and getData methods of Vector3D");
    vecA.setData(0,4.5);
    System.out.println(vecA.getData(0));
    vecA.setData(1,5.5);
    System.out.println(vecA.getData(1));
    vecA.setData(2,6.5);
    System.out.println(vecA.getData(2));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Vector3D class.

    System.out.println(
                  "Test getColMatrix method of Vector3D");
    System.out.println(vecA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Vector3D");
    GM01.Vector3D vecB = new GM01.Vector3D(
                       new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(vecA.equals(vecB));
    vecB.setData(0,4.5);
    vecB.setData(1,5.5);
    vecB.setData(2,6.5);
    System.out.println(vecA.equals(vecB));

    System.out.println("Test add method of Vector3D");
    System.out.println(vecA);
    vecB = new GM01.Vector3D(
                      new GM01.ColMatrix3D(-1.5,2.5,3.5));
    System.out.println(vecB);
    System.out.println(vecA.add(vecB));
    System.out.println();

    System.out.println(
                     "Test getLength method of Vector3D");
    vecA = new GM01.Vector3D(
                       new GM01.ColMatrix3D(3.0,4.0,5.0));
    System.out.println(vecA);
    System.out.println(vecA.getLength());
    System.out.println();

    System.out.println("Test toString method of Line3D");
    GM01.Line3D lineA = new GM01.Line3D(pointA,pointB);
    System.out.println(lineA);
    System.out.println();

    System.out.println("Test setTail, setHead, getTail, "
                     + "nand getHead methods of Line3D");
    lineA.setTail(pointB);
    lineA.setHead(pointA);
    System.out.println(lineA.getTail());
    System.out.println(lineA.getHead());
    System.out.println();
  }//end testUsingText
  //----------------------------------------------------//

  //The purpose of this method is to test various
  // 3D aspects of the library using graphics.
  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);

    //Define eight points that define the corners of
    // a box in 3D that is centered on the origin.

    GM01.Point3D[] points = new GM01.Point3D[8];
    //Right side
    points[0] = 
         new GM01.Point3D(new GM01.ColMatrix3D(75,75,75));
    points[1] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,75,-75));
    points[2] = 
       new GM01.Point3D(new GM01.ColMatrix3D(75,-75,-75));
    points[3] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,-75,75));
    //Left side
    points[4] = 
        new GM01.Point3D(new GM01.ColMatrix3D(-75,75,75));
    points[5] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,75,-75));
    points[6] = 
      new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,-75));
    points[7] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,75));

    //Draw seven of the points in BLACK
    g2D.setColor(Color.BLACK);
    for(int cnt = 1;cnt < points.length;cnt++){
      points[cnt].draw(g2D);
    }//end for loop

    //Draw the right top front point in RED to identify
    // it.
    g2D.setColor(Color.RED);
    points[0].draw(g2D);
    g2D.setColor(Color.BLACK);

    //Draw lines that connect the points to define the
    // twelve edges of the box.
    //Right side
    new GM01.Line3D(points[0],points[1]).draw(g2D);
    new GM01.Line3D(points[1],points[2]).draw(g2D);
    new GM01.Line3D(points[2],points[3]).draw(g2D);
    new GM01.Line3D(points[3],points[0]).draw(g2D);

    //Left side
    new GM01.Line3D(points[4],points[5]).draw(g2D);
    new GM01.Line3D(points[5],points[6]).draw(g2D);
    new GM01.Line3D(points[6],points[7]).draw(g2D);
    new GM01.Line3D(points[7],points[4]).draw(g2D);

    //Front
    new GM01.Line3D(points[0],points[4]).draw(g2D);
    new GM01.Line3D(points[3],points[7]).draw(g2D);

    //Back
    new GM01.Line3D(points[1],points[5]).draw(g2D);
    new GM01.Line3D(points[2],points[6]).draw(g2D);


    //Define a vector.
    GM01.Vector3D vecA = new GM01.Vector3D(
                        new GM01.ColMatrix3D(75,-75,-75));

    //Draw the vector with its tail at the upper-left
    // corner of the box. The length and direction of the
    // vector will cause its head to be at the origin.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,points[4]);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image and to draw orthogonal 3D axes on
  // the off-screen image that intersect at the origin.
  // The lengths of the axes are set so as to match the
  // interior dimensions of the box and points are drawn
  // where the axes intersect the surfaces of the box.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.Point3D pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(-75,0,0));
    GM01.Point3D pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(75,0,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,-75,0));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,75,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw z-axis in BLUE
    g2D.setColor(Color.BLUE);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,0,-75));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,0,75));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method
  //====================================================//


  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas

}//end class GUI
//======================================================//

/*GM01test05.java
Copyright 2008, R.G.Baldwin
Revised 02/24/08

This program illustrates vector addition in 3D.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;

class GM01test05{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class GM01test05
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 300;
  int vSize = 200;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas

  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());

    //Draw on the off-screen image.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//

  //The purpose of this method is to illustrate vector
  // addition in 3D
  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen image, draw a
    // pair of orthogonal axes on it that intersect at the
    // origin, and paint the background white.
    setCoordinateFrame(g2D);

    //Define two vectors that will be added.
    GM01.Vector3D vecA = new GM01.Vector3D(
                         new GM01.ColMatrix3D(75,75,75));
                        
    GM01.Vector3D vecB = new GM01.Vector3D(
                        new GM01.ColMatrix3D(-15,10,-50));

    //Create a ref point at the origin for convenience.
    GM01.Point3D zeroPoint = new GM01.Point3D(
                             new GM01.ColMatrix3D(0,0,0));

    //Draw vecA in MAGENTA with its tail at the origin.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,zeroPoint);

    //Draw vecB in LIGHT_GRAY with its tail at the head
    // of vecA.
    g2D.setColor(Color.LIGHT_GRAY);
    GM01.Point3D temp = 
                    new GM01.Point3D(vecA.getColMatrix());
    vecB.draw(g2D,temp);

    //Draw vecB in LIGHT_GRAY with its tail at the origin.
    vecB.draw(g2D,zeroPoint);

    //Draw vecA in MAGENTA with its tail at the head
    // of vecB. This completes a trapezoid.
    g2D.setColor(Color.MAGENTA);
    vecA.draw(g2D,new GM01.Point3D(vecB.getColMatrix()));

    //Add the two vectors.
    GM01.Vector3D sum = vecA.add(vecB);
    //Draw sum in BLACK with its tail at the origin.
    g2D.setColor(Color.BLACK);
    sum.draw(g2D,zeroPoint);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image, set the background color to WHITE,
  // and draw orthogonal 3D axes on the off-screen image
  // that intersect at the origin.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    
    //Set background color to WHITE.
    g2D.setColor(Color.WHITE);
    GM01.fillRect(
          g2D,-osiWidth/2,osiHeight/2,osiWidth,osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.Point3D pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(-75,0,0));
    GM01.Point3D pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(75,0,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,-75,0));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,75,0));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw z-axis in BLUE
    g2D.setColor(Color.BLUE);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,0,-75));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,0,75));
    pointA.draw(g2D);
    pointB.draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method
  //====================================================//

  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas
    
}//end class GUI
//======================================================//

/*GM01test06.java
Copyright 2008, R.G.Baldwin
Revised 02/24/08

This program is an update of the program named GM01test01.
The purpose is to illustrate scaling a geometric object
by calling the method named GM01.Point3D.scale for each
point that makes up the object.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;

class GM01test06{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class GM01test06
//======================================================//

class GUI extends JFrame{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 400;
  int vSize = 400;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas

  GUI(){//constructor
    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Create a new drawing canvas and add it to the
    // center of the JFrame.
    myCanvas = new MyCanvas();
    this.getContentPane().add(myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    Graphics2D g2D = (Graphics2D)(osi.getGraphics());

    //Test many 3D library features using text.
    testUsingText();

    //Test many 3D library features using graphics.
    drawOffScreen(g2D);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//

    //The purpose of this method is to test various
    // 3D aspects of the library using text.
  public void testUsingText(){
    System.out.println(
               "Test overridden toString of ColMatrix3D");
    GM01.ColMatrix3D tempA = 
                        new GM01.ColMatrix3D(1.5,2.5,3.5);
    System.out.println(tempA);
    System.out.println();

    System.out.println(
               "Test setData and getData of ColMatrix3D");
    tempA.setData(0,4.5);
    System.out.println(tempA.getData(0));
    tempA.setData(1,5.5);
    System.out.println(tempA.getData(1));
    tempA.setData(2,6.5);
    System.out.println(tempA.getData(2));
    System.out.println();

    System.out.println(
                     "Test equals method of ColMatrix3D");
    GM01.ColMatrix3D tempB = 
                        new GM01.ColMatrix3D(1.5,2.5,3.5);
    System.out.println(tempA.equals(tempB));
    tempB.setData(0,4.5);
    tempB.setData(1,5.5);
    tempB.setData(2,6.5);
    System.out.println(tempA.equals(tempB));
    System.out.println();

    System.out.println("Test add method of ColMatrix3D");
    System.out.println(tempA.add(tempB));
    System.out.println();

    System.out.println(
                   "Test subtract method of ColMatrix3D");
    System.out.println(tempA.subtract(tempB));
    System.out.println();

    System.out.println("Test toString method of Point3D");
    GM01.Point3D pointA = new GM01.Point3D(tempA);
    System.out.println(pointA);
    System.out.println();

    System.out.println(
                   "Test setData and getData of Point3D");
    pointA.setData(0,1.1);
    System.out.println(pointA.getData(0));
    pointA.setData(1,2.2);
    System.out.println(pointA.getData(1));
    pointA.setData(2,3.3);
    System.out.println(pointA.getData(2));
    System.out.println();

    System.out.println("Test getColMatrix of Point3D");
    System.out.println(pointA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Point3D");
    GM01.Point3D pointB = new GM01.Point3D(tempB);
    System.out.println(pointA.equals(pointB));
    pointA = new GM01.Point3D(tempB);
    System.out.println(pointA.equals(pointB));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Point3D class.

    System.out.println(
          "Test getDisplacementVector method of Point3D");
    pointA = 
      new GM01.Point3D(new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(pointA);
    System.out.println(pointB);
    System.out.println(
                    pointA.getDisplacementVector(pointB));
    System.out.println();

    System.out.println(
               "Test addVectorToPoint method of Point3D");
    System.out.println(pointA);
    System.out.println(pointA.addVectorToPoint(
                   new GM01.Vector3D(
                     new GM01.ColMatrix3D(5.5,6.5,7.5))));
    System.out.println();

    System.out.println(
                      "Test toString method of Vector3D");
    GM01.Vector3D vecA = new GM01.Vector3D(
                       new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(vecA);
    System.out.println();

    System.out.println(
          "Test setData and getData methods of Vector3D");
    vecA.setData(0,4.5);
    System.out.println(vecA.getData(0));
    vecA.setData(1,5.5);
    System.out.println(vecA.getData(1));
    vecA.setData(2,6.5);
    System.out.println(vecA.getData(2));
    System.out.println();

    //See the method named drawOffScreen for a test of
    // the draw method of the Vector3D class.

    System.out.println(
                  "Test getColMatrix method of Vector3D");
    System.out.println(vecA.getColMatrix());
    System.out.println();

    System.out.println("Test equals method of Vector3D");
    GM01.Vector3D vecB = new GM01.Vector3D(
                       new GM01.ColMatrix3D(1.5,2.5,3.5));
    System.out.println(vecA.equals(vecB));
    vecB.setData(0,4.5);
    vecB.setData(1,5.5);
    vecB.setData(2,6.5);
    System.out.println(vecA.equals(vecB));

    System.out.println("Test add method of Vector3D");
    System.out.println(vecA);
    vecB = new GM01.Vector3D(
                      new GM01.ColMatrix3D(-1.5,2.5,3.5));
    System.out.println(vecB);
    System.out.println(vecA.add(vecB));
    System.out.println();

    System.out.println(
                     "Test getLength method of Vector3D");
    vecA = new GM01.Vector3D(
                       new GM01.ColMatrix3D(3.0,4.0,5.0));
    System.out.println(vecA);
    System.out.println(vecA.getLength());
    System.out.println();

    System.out.println("Test toString method of Line3D");
    GM01.Line3D lineA = new GM01.Line3D(pointA,pointB);
    System.out.println(lineA);
    System.out.println();

    System.out.println("Test setTail, setHead, getTail, "
                     + "nand getHead methods of Line3D");
    lineA.setTail(pointB);
    lineA.setHead(pointA);
    System.out.println(lineA.getTail());
    System.out.println(lineA.getHead());
    System.out.println();
  }//end testUsingText
  //----------------------------------------------------//

  //The purpose of this method is to test various
  // 3D aspects of the library using graphics.
  void drawOffScreen(Graphics2D g2D){

    //Translate the origin on the off-screen
    // image and draw a pair of orthogonal axes on it.
    setCoordinateFrame(g2D);

    //Define eight points that define the corners of
    // a box in 3D that is centered on the origin.

    GM01.Point3D[] points = new GM01.Point3D[8];
    //Right side
    points[0] = 
         new GM01.Point3D(new GM01.ColMatrix3D(75,75,75));
    points[1] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,75,-75));
    points[2] = 
       new GM01.Point3D(new GM01.ColMatrix3D(75,-75,-75));
    points[3] = 
        new GM01.Point3D(new GM01.ColMatrix3D(75,-75,75));
    //Left side
    points[4] = 
        new GM01.Point3D(new GM01.ColMatrix3D(-75,75,75));
    points[5] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,75,-75));
    points[6] = 
      new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,-75));
    points[7] = 
       new GM01.Point3D(new GM01.ColMatrix3D(-75,-75,75));

    //Scale each of the points that define the corners of
    // the box.
    for(int cnt = 0;cnt < points.length;cnt++){
      points[cnt] = points[cnt].scale(
                     new GM01.ColMatrix3D(0.25,0.5,0.75));
    }//end for loop

    //Draw seven of the points in BLACK
    g2D.setColor(Color.BLACK);
    for(int cnt = 1;cnt < points.length;cnt++){
      points[cnt].draw(g2D);
    }//end for loop

    //Draw the right top front point in RED to identify
    // it.
    g2D.setColor(Color.RED);
    points[0].draw(g2D);
    g2D.setColor(Color.BLACK);

    //Draw lines that connect the points to define the
    // twelve edges of the box.
    //Right side
    new GM01.Line3D(points[0],points[1]).draw(g2D);
    new GM01.Line3D(points[1],points[2]).draw(g2D);
    new GM01.Line3D(points[2],points[3]).draw(g2D);
    new GM01.Line3D(points[3],points[0]).draw(g2D);

    //Left side
    new GM01.Line3D(points[4],points[5]).draw(g2D);
    new GM01.Line3D(points[5],points[6]).draw(g2D);
    new GM01.Line3D(points[6],points[7]).draw(g2D);
    new GM01.Line3D(points[7],points[4]).draw(g2D);

    //Front
    new GM01.Line3D(points[0],points[4]).draw(g2D);
    new GM01.Line3D(points[3],points[7]).draw(g2D);

    //Back
    new GM01.Line3D(points[1],points[5]).draw(g2D);
    new GM01.Line3D(points[2],points[6]).draw(g2D);

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image and to draw orthogonal 3D axes on
  // the off-screen image that intersect at the origin.
  // Points are drawn where the axes intersect the
  // surfaces of the box.
  private void setCoordinateFrame(Graphics2D g2D){

    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);

    //Draw x-axis in RED. Scale the points before
    // drawing them so that they will identify the
    // locations where the axes intersect the surface
    // of the box.
    g2D.setColor(Color.RED);
    GM01.Point3D pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(-75,0,0));
    GM01.Point3D pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(75,0,0));
    pointA.scale(
            new GM01.ColMatrix3D(0.25,0.0,0.0)).draw(g2D);
    pointB.scale(
            new GM01.ColMatrix3D(0.25,0.0,0.0)).draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,-75,0));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,75,0));
    pointA.scale(
             new GM01.ColMatrix3D(0.0,0.5,0.0)).draw(g2D);
    pointB.scale(
             new GM01.ColMatrix3D(0.0,0.5,0.0)).draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw z-axis in BLUE
    g2D.setColor(Color.BLUE);
    pointA = 
          new GM01.Point3D(new GM01.ColMatrix3D(0,0,-75));
    pointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(0,0,75));
    pointA.scale(
            new GM01.ColMatrix3D(0.0,0.0,0.75)).draw(g2D);
    pointB.scale(
            new GM01.ColMatrix3D(0.0,0.0,0.75)).draw(g2D);
    new GM01.Line3D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method
  //====================================================//


  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas

}//end class GUI
//======================================================//

/*StringArt02.java
Copyright 2008, R.G.Baldwin
Revised 02/22/08

This is a 2D version of a string art program that supports
rotation in two dimensions.

This program produces a 2D string art image by connecting
various points that are equally spaced on the 
circumference of a circle.

Initially, the circle is centered on the origin. There are
six points on the circle connected by lines forming a 
hexagon, The lines that connect the points are different 
colors. The radius of the circle is 50 units. The points 
at the vertices of the hexagon are not drawn, but the 
lines that connect the vertices are drawn.

A GUI is provided that allows the user to specify the 
following items and click a Replot button to cause the 
drawing to change:

Number Points
Number Loops
Rotation angle (deg)
X anchor point
Y anchor point


Changing the number of points causes the number of 
vertices that describe the geometric object to change.

Changing the number of loops causes the number of lines
that are drawn to connect the vertices to change. For a
value of 1, each vertex is connected to the one next to
it. For a value of 2, additional lines are drawn 
connecting every other vertex. For a value of 3, 
additional lines are drawn connecting every third vertex,
etc.

The image can be rotated around an anchor point. Entering 
a non-zero value in the Rotation field causes the image 
to be rotated by the specified angle around the anchor 
point.

The anchor point is initially located at the origin, but 
the location of the anchor point can be changed by the 
user. If the anchor point is at the origin, the image is 
rotated around the origin. Otherwise, the image is rotated
around the point in 2D space specified by the anchor 
point. The anchor point is drawn in black.

The rotation angle is specified in degrees with a positive
angle being counter-clockwise.

The number of points is initially set to six and the 
number of loops is initially set to one.  Making the 
number of points larger and making the number of loops 
larger produces many interesting patterns.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;
import java.awt.event.*;

class StringArt02{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class StringArt02
//======================================================//

class GUI extends JFrame implements ActionListener{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 300;
  int vSize = 470;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas 
  Graphics2D g2D;//off-screen graphics context.

  JTextField numberPointsField;//User input field.
  JTextField loopsField;//User input field.
  int numberPoints = 6;//Can be modified by the user.
  int loopLim = 1;//Can be modified by the user.

  JTextField rotationField;//User input field
  double rotation;//Rotation angle in degrees clockwise.

  JTextField xAnchorPointField;//User input field
  JTextField yAnchorPointField;//User input field
  double xAnchorPoint;//Rotation anchor point.
  double yAnchorPoint;//Rotation anchor point.

  //The following variable is used to refer to an array
  // object containing the points that define the
  // vertices of a geometric object.
  GM01.Point2D[] points;

  //----------------------------------------------------//

  GUI(){//constructor
    //Instantiate the array object that will be used to
    // store the points that define the vertices of the
    // geometric object.
    points = new GM01.Point2D[numberPoints];

    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Instantiate the user input components.
    numberPointsField =new JTextField("6");
    loopsField = new JTextField("1");
    rotationField = new JTextField("0");
    xAnchorPointField = new JTextField("0");
    yAnchorPointField = new JTextField("0");
    JButton button = new JButton("Replot");

    //Instantiate a JPanel that will house the user input
    // components and set its layout manager.
    JPanel controlPanel = new JPanel();
    controlPanel.setLayout(new GridLayout(0,2));

    //Add the user input components and appropriate labels
    // to the control panel.
    controlPanel.add(new JLabel(" Number Points"));    
    controlPanel.add(numberPointsField);
    controlPanel.add(new JLabel(" Number Loops"));
    controlPanel.add(loopsField);
    controlPanel.add(new JLabel(
                               " Rotation angle (deg)"));
    controlPanel.add(rotationField);
    controlPanel.add(new JLabel(" X anchor point"));
    controlPanel.add(xAnchorPointField);
    controlPanel.add(new JLabel(" Y anchor point"));
    controlPanel.add(yAnchorPointField);
    controlPanel.add(button);

    //Add the control panel to the SOUTH position in the
    // JFrame.
    this.getContentPane().add(
                         BorderLayout.SOUTH,controlPanel);

    //Create a new drawing canvas and add it to the
    // CENTER of the JFrame above the control panel.
    myCanvas = new MyCanvas();
    this.getContentPane().add(
                            BorderLayout.CENTER,myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);

    //Make the size of the off-screen image match the
    // size of the canvas.
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    g2D = (Graphics2D)(osi.getGraphics());

    //Erase the off-screen image, establish the origin,
    // and draw the axes
    setCoordinateFrame(g2D,true);

    //Create the Point2D objects that define the geometric
    // object and manipulate them to produce the desired
    // results.
    drawOffScreen(g2D);

    //Register this object as an action listener on the
    // button.
    button.addActionListener(this);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();
    
  }//end constructor
  //----------------------------------------------------//

  //The purpose of this method is to Create the Point2D
  // objects that define the vertices of a geometric
  // object and manipulate them to produce the desired
  // results.
  void drawOffScreen(Graphics2D g2D){
    //Erase the off-screen image and draw new axes, but
    // don't move the origin.
    setCoordinateFrame(g2D,false);

    //Create a set of Point2D objects that specify
    // locations on the circumference of a circle that
    // is in the x-y plane with a radius of 50 units. Save
    // references to the Point2D objects in an array.
    for(int cnt = 0;cnt < numberPoints;cnt++){
      points[cnt] = new GM01.Point2D(new GM01.ColMatrix2D(
        50*Math.cos((cnt*360/numberPoints)*Math.PI/180),
        50*Math.sin((cnt*360/numberPoints)*Math.PI/180)));

      //The following object is populated with the 2D 
      // coordinates of the point around which the 
      //rotations will take place.
      GM01.Point2D anchorPoint = new GM01.Point2D(
                            new GM01.ColMatrix2D(
                              xAnchorPoint,yAnchorPoint));
      //Draw the anchorPoint in BLACK.
      g2D.setColor(Color.BLACK);
      anchorPoint.draw(g2D);

      //The following statement causes the rotation to be 
      //performed.
      points[cnt] = 
                 points[cnt].rotate(anchorPoint,rotation);

    }//end for loop

    //Implement the algorithm that draws lines connecting
    // points on the geometric object.
    GM01.Line2D line;

    //Begin the outer loop.
    for(int loop = 1;loop <= loopLim;loop++){
      //The following variable specifies the array
      // element containing a point on which a line will
      // start.
      int start = -1;

      //The following variable specifies the number of
      // points that will be skipped between the starting
      // point and the ending point for a line.
      int skip = loop;
      //The following logic causes the element number to
      // wrap around when it reaches the end of the
      // array.
      while(skip >= 2*numberPoints-1){
        skip -= numberPoints;
      }//end while loop

      //The following variable specifies the array
      // element containing a point on which a line will
      // end.
      int end = start + skip;

      //Begin inner loop. This loop actually constructs
      // the GM01.Line2D objects and causes visual
      // manifestations of those objects to be drawn on
      // the off-screen image. Note the requirement to
      // wrap around when the element numbers exceed the
      // length of the array.
      for(int cnt = 0;cnt < numberPoints;cnt++){
        if(start < numberPoints-1){
          start++;
        }else{
          //Wrap around
          start -= (numberPoints-1);
        }//end else

        if(end < numberPoints-1){
          end++;
        }else{
          //Wrap around.
          end -= (numberPoints-1);
        }//end else

        //Create some interesting colors.
        g2D.setColor(new Color(cnt*255/numberPoints,
                               127+cnt*64/numberPoints,
                               255-cnt*255/numberPoints));

        //Create a line that connects points on the
        // geometric object.
        line = new GM01.Line2D(points[start],points[end]);
        line.draw(g2D);
      }//end inner loop
    }//end outer loop

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image to the center and to draw orthogonal
  // 2D axes on the image that intersect at the origin.
  //The second parameter is used to determine if the
  // origin should be translated to the center.
  private void setCoordinateFrame(
                        Graphics2D g2D,boolean translate){

    //Translate the origin to the center if translate is
    // true.
    if(translate){
      GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    }//end if

    //Erase the screen
    g2D.setColor(Color.WHITE);
    GM01.fillRect(g2D,-osiWidth/2,osiHeight/2,
                                      osiWidth,osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.Point2D pointA = new GM01.Point2D(
                   new GM01.ColMatrix2D(-osiWidth/2,0));
    GM01.Point2D pointB = new GM01.Point2D(
                    new GM01.ColMatrix2D(osiWidth/2,0));
    new GM01.Line2D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = new GM01.Point2D(
                  new GM01.ColMatrix2D(0,-osiHeight/2));
    pointB = new GM01.Point2D(
                   new GM01.ColMatrix2D(0,osiHeight/2));
    new GM01.Line2D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method
  //----------------------------------------------------//

  //This method is called to respond to a click on the
  // button.
  public void actionPerformed(ActionEvent e){
    //Get user input values and use them to modify several
    // values that control the drawing.
    numberPoints = Integer.parseInt(
                             numberPointsField.getText());

    loopLim = Integer.parseInt(loopsField.getText());

    //Rotation angle in degrees.
    rotation = 
             Double.parseDouble(rotationField.getText());

    //Rotation anchor points
    xAnchorPoint = 
          Double.parseDouble(xAnchorPointField.getText());
    yAnchorPoint = 
          Double.parseDouble(yAnchorPointField.getText());

    //Instantiate a new array object with a length
    // that matches the new value for numberPoints.    
    points = new GM01.Point2D[numberPoints];

    //Draw a new off-screen image based on user inputs.
    drawOffScreen(g2D);
    myCanvas.repaint();//Copy off-screen image to canvas.
  }//end actionPerformed
  //====================================================//


  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas

}//end class GUI
//======================================================//

/*StringArt03.java
Copyright 2008, R.G.Baldwin
Revised 02/22/08

This is a 3D version of a string art program that supports
rotation in three dimensions.

This program produces a 3D string art image by connecting
various points that are equally spaced on the 
circumference of a circle.

Initially, the circle is on the x-y plane centered on the 
origin. There are six points on the circle connected by
lines forming a hexagon, The lines that connect the points
are different colors. The radius of the circle is 50 
units. The points at the vertices of the hexagon are not 
drawn, but the lines that connect the vertices are drawn.

A GUI is provided that allows the user to specify the 
following items and click a Replot button to cause the 
drawing to change:

Number Points
Number Loops
Rotate around Z (deg)
Rotate around X (deg)
Rotate around Y (deg)
X Anchor point
Y Anchor point
Z Anchor point

Changing the number of points causes the number of 
vertices that describe the geometric object to change.

Changing the number of loops causes the number of lines
that are drawn to connect the vertices to change. For a
value of 1, each vertex is connected to the one next to
it. For a value of 2, additional lines are drawn 
connecting every other vertex. For a value of 3, 
additional lines are drawn connecting every third vertex,
etc.

The image can be rotated in any or all of three 
dimensions around an anchor point. Entering a non-zero 
value in one or more of the Rotate fields causes the 
image to be rotated by the specified angle or angles 
around the anchor point. The anchor point is initially
specified to be at the origin, but the location of the
anchor point can be changed by the user. If the anchor 
point is at the origin, the image is rotated around the 
origin. Otherwise, the image is rotated around the point
in 3D space specified by the anchor point. The anchor 
point is drawn in black.

The rotation angle is specified in degrees with a positive
angle being given by the right-hand rule as applied to the
axis around which the image is being rotated.

The rotational effects are cumulative. The image is first 
rotated around the anchor point in a direction consistent 
with rotation around the z-axis (rotation in the x-y 
plane). Then that rotated image is rotated in a direction 
consistent with rotation around the x-axis (rotation in 
the y-z plane). Finally, the previously rotated image is 
rotated in a direction consistent with rotation around the
y-axis (rotation in the x-z plane). It is important
to note, however, that the actual rotation is around the 
anchor point and not around the origin unless the anchor
point is at the origin.

The number of points is initially set to six and the 
number of loops is initially set to one.  Making the 
number of points larger and making the number of loops 
larger produces many interesting patterns.

Tested using JDK 1.6 under WinXP.
*********************************************************/
import java.awt.*;
import javax.swing.*;
import java.awt.geom.*;
import java.awt.event.*;

class StringArt03{
  public static void main(String[] args){
    GUI guiObj = new GUI();
  }//end main
}//end controlling class StringArt03
//======================================================//

class GUI extends JFrame implements ActionListener{
  //Specify the horizontal and vertical size of a JFrame
  // object.
  int hSize = 300;
  int vSize = 470;
  Image osi;//an off-screen image
  int osiWidth;//off-screen image width
  int osiHeight;//off-screen image height
  MyCanvas myCanvas;//a subclass of Canvas 
  Graphics2D g2D;//Off-screen graphics context.

  JTextField numberPointsField;//User input field.
  JTextField loopsField;//User input field.
  int numberPoints = 6;//Can be modified by the user.
  int loopLim = 1;//Can be modified by the user.

  JTextField zRotationField;//User input field
  JTextField xRotationField;//User input field
  JTextField yRotationField;//User input field
  double zRotation;//Rotation around z in degrees.
  double xRotation;//Rotation around x in degrees.
  double yRotation;//Rotation around y in degrees

  JTextField xAnchorPointField;//User input field
  JTextField yAnchorPointField;//User input field
  JTextField zAnchorPointField;//User input field
  double xAnchorPoint;//Rotation anchor point.
  double yAnchorPoint;//Rotation anchor point.
  double zAnchorPoint;//Rotation anchor point.


  //The following variable is used to refer to an array
  // object containing the points that define the
  // vertices of a geometric object.
  GM01.Point3D[] points;

  //----------------------------------------------------//

  GUI(){//constructor
    //Instantiate the array object that will be used to
    // store the points that define the vertices of the
    // geometric object.
    points = new GM01.Point3D[numberPoints];

    //Set JFrame size, title, and close operation.
    setSize(hSize,vSize);
    setTitle("Copyright 2008,R.G.Baldwin");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    //Instantiate the user input components.
    numberPointsField =new JTextField("6");
    loopsField = new JTextField("1");
    zRotationField = new JTextField("0");
    xRotationField = new JTextField("0");
    yRotationField = new JTextField("0");
    xAnchorPointField = new JTextField("0");
    yAnchorPointField = new JTextField("0");
    zAnchorPointField = new JTextField("0");
    JButton button = new JButton("Replot");

    //Instantiate a JPanel that will house the user input
    // components and set its layout manager.
    JPanel controlPanel = new JPanel();
    controlPanel.setLayout(new GridLayout(0,2));

    //Add the user input components and appropriate labels
    // to the control panel.
    controlPanel.add(new JLabel(" Number Points"));    
    controlPanel.add(numberPointsField);
    controlPanel.add(new JLabel(" Number Loops"));
    controlPanel.add(loopsField);
    controlPanel.add(new JLabel(
                               " Rotate around Z (deg)"));
    controlPanel.add(zRotationField);
    controlPanel.add(new JLabel(
                               " Rotate around X (deg)"));
    controlPanel.add(xRotationField);
    controlPanel.add(new JLabel(
                               " Rotate around Y (deg)"));
    controlPanel.add(yRotationField);
    controlPanel.add(new JLabel(" X anchor point"));
    controlPanel.add(xAnchorPointField);
    controlPanel.add(new JLabel(" Y anchor point"));
    controlPanel.add(yAnchorPointField);
    controlPanel.add(new JLabel(" Z anchor point"));
    controlPanel.add(zAnchorPointField);
    controlPanel.add(button);

    //Add the control panel to the SOUTH position in the
    // JFrame.
    this.getContentPane().add(
                         BorderLayout.SOUTH,controlPanel);

    //Create a new drawing canvas and add it to the
    // CENTER of the JFrame above the control panel.
    myCanvas = new MyCanvas();
    this.getContentPane().add(
                            BorderLayout.CENTER,myCanvas);

    //This object must be visible before you can get an
    // off-screen image.  It must also be visible before
    // you can compute the size of the canvas.
    setVisible(true);

    //Make the size of the off-screen image match the
    // size of the canvas.
    osiWidth = myCanvas.getWidth();
    osiHeight = myCanvas.getHeight();

    //Create an off-screen image and get a graphics
    // context on it.
    osi = createImage(osiWidth,osiHeight);
    g2D = (Graphics2D)(osi.getGraphics());

    //Erase the off-screen image, establish the origin,
    // and draw the axes
    setCoordinateFrame(g2D,true);

    //Create the Point3D objects that define the geometric
    // object and manipulate them to produce the desired
    // results.
    drawOffScreen(g2D);

    //Register this object as an action listener on the
    // button.
    button.addActionListener(this);

    //Cause the overridden paint method belonging to
    // myCanvas to be executed.
    myCanvas.repaint();

  }//end constructor
  //----------------------------------------------------//
  
  //The purpose of this method is to Create the Point3D
  // objects that define the vertices of a geometric
  // object and manipulate them to produce the desired
  // results.
  void drawOffScreen(Graphics2D g2D){
    //Erase the off-screen image and draw new axes, but
    // don't move the origin.
    setCoordinateFrame(g2D,false);


    //Create a set of Point3D objects that specify
    // locations on the circumference of a circle that
    // is in the x-y plane with a radius of 50 units. Save
    // references to the Point3D objects in an array.
    for(int cnt = 0;cnt < numberPoints;cnt++){
      points[cnt] = new GM01.Point3D(
        new GM01.ColMatrix3D(
          50*Math.cos((cnt*360/numberPoints)*Math.PI/180),
          50*Math.sin((cnt*360/numberPoints)*Math.PI/180),
          0.0));

      //The following ColMatrix3D object must be populated
      // with three rotation angles in degrees that
      // specify the following rotational angles in order
      // according to the right-hand rule as applied to 
      // the indicated axis.
      // Rotate around z
      // Rotate around x
      // Rotate around y
      GM01.ColMatrix3D angles = new GM01.ColMatrix3D(
                           zRotation,xRotation,yRotation);

      //The following object contains the 3D coordinates
      // of the point around which the rotations will
      // take place.
      GM01.Point3D anchorPoint = new GM01.Point3D(
               new GM01.ColMatrix3D(
                 xAnchorPoint,yAnchorPoint,zAnchorPoint));
      //Draw the anchorPoint in BLACK.
      g2D.setColor(Color.BLACK);
      anchorPoint.draw(g2D);

      //The following statement causes the rotation to be 
      //performed.
      points[cnt] = 
                   points[cnt].rotate(anchorPoint,angles);

    }//end for loop

    //Implement the algorithm that draws lines connecting
    // points on the geometric object.
    GM01.Line3D line;

    //Begin the outer loop.
    for(int loop = 1;loop <= loopLim;loop++){
      //The following variable specifies the array
      // element containing a point on which a line will
      // start.
      int start = -1;

      //The following variable specifies the number of
      // points that will be skipped between the starting
      // point and the ending point for a line.
      int skip = loop;
      //The following logic causes the element number to
      // wrap around when it reaches the end of the
      // array.
      while(skip >:= 2*numberPoints-1){
        skip -= numberPoints;
      }//end while loop

      //The following variable specifies the array
      // element containing a point on which a line will
      // end.
      int end = start + skip;

      //Begin inner loop. This loop actually constructs
      // the GM01.Line3D objects and causes visual
      // manifestations of those objects to be drawn on
      // the off-screen image. Note the requirement to
      // wrap around when the element numbers exceed the
      // length of the array.
      for(int cnt = 0;cnt < numberPoints;cnt++){
        if(start < numberPoints-1){
          start++;
        }else{
          //Wrap around
          start -= (numberPoints-1);
        }//end else

        if(end < numberPoints-1){
          end++;
        }else{
          //Wrap around.
          end -= (numberPoints-1);
        }//end else

        //Create some interesting colors.
        g2D.setColor(new Color(cnt*255/numberPoints,
                               127+cnt*64/numberPoints,
                               255-cnt*255/numberPoints));

        //Create a line that connects points on the
        // geometric object.
        line = new GM01.Line3D(points[start],points[end]);
        line.draw(g2D);
      }//end inner loop
    }//end outer loop

  }//end drawOffScreen
  //----------------------------------------------------//

  //This method is used to set the origin of the
  // off-screen image to the center and to draw orthogonal
  // 3D axes on the image that intersect at the origin.
  //The second parameter is used to determine if the
  // origin should be translated to the center.
  private void setCoordinateFrame(
                        Graphics2D g2D,boolean translate){

    //Translate the origin to the center if translate is
    // true.
    if(translate){
      GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    }//end if

    //Erase the screen
    g2D.setColor(Color.WHITE);
    GM01.fillRect(g2D,-osiWidth/2,osiHeight/2,
                                      osiWidth,osiHeight);

    //Draw x-axis in RED
    g2D.setColor(Color.RED);
    GM01.Point3D pointA = new GM01.Point3D(
                   new GM01.ColMatrix3D(-osiWidth/2,0,0));
    GM01.Point3D pointB = new GM01.Point3D(
                    new GM01.ColMatrix3D(osiWidth/2,0,0));
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw y-axis in GREEN
    g2D.setColor(Color.GREEN);
    pointA = new GM01.Point3D(
                  new GM01.ColMatrix3D(0,-osiHeight/2,0));
    pointB = new GM01.Point3D(
                   new GM01.ColMatrix3D(0,osiHeight/2,0));
    new GM01.Line3D(pointA,pointB).draw(g2D);

    //Draw z-axis in BLUE. Make its length the same as the
    // length of the x-axis.
    g2D.setColor(Color.BLUE);
    pointA = new GM01.Point3D(
                   new GM01.ColMatrix3D(0,0,-osiWidth/2));
    pointB = new GM01.Point3D(
                    new GM01.ColMatrix3D(0,0,osiWidth/2));
    new GM01.Line3D(pointA,pointB).draw(g2D);

  }//end setCoordinateFrame method
  //----------------------------------------------------//

  //This method is called to respond to a click on the
  // button.
  public void actionPerformed(ActionEvent e){
    //Get user input values and use them to modify several
    // values that control the drawing.
    numberPoints = Integer.parseInt(
                             numberPointsField.getText());

    loopLim = Integer.parseInt(loopsField.getText());

    //Rotation around z in degrees.
    zRotation = 
             Double.parseDouble(zRotationField.getText());
    //Rotation around x in degrees.
    xRotation = 
             Double.parseDouble(xRotationField.getText());
    //Rotation around y in degrees
    yRotation = 
             Double.parseDouble(yRotationField.getText());

    //Rotation anchor points
    xAnchorPoint = 
          Double.parseDouble(xAnchorPointField.getText());
    yAnchorPoint = 
          Double.parseDouble(yAnchorPointField.getText());
    zAnchorPoint = 
          Double.parseDouble(zAnchorPointField.getText());

    //Instantiate a new array object with a length
    // that matches the new value for numberPoints.
    points = new GM01.Point3D[numberPoints];

    //Draw a new off-screen image based on user inputs.
    drawOffScreen(g2D);
    myCanvas.repaint();//Copy off-screen image to canvas.
  }//end actionPerformed
  //====================================================//


  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the paint() method. This method will be
    // called when the JFrame and the Canvas appear on the
    // screen or when the repaint method is called on the
    // Canvas object.
    //The purpose of this method is to display the
    // off-screen image on the screen.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
    
  }//end inner class MyCanvas

}//end class GUI
//======================================================//