/*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
//======================================================//

/*GM01test08.java 
Copyright 2008, R.G.Baldwin
Revised 02/28/08.

This is an interactive 3D game program  This game 
simulates a school of prey fish being attacked and eaten
by a predator. The objective for the player is to cause 
the predator to catch and eat all of the prey fish in a 
minimum amount of time.

The strategy is for the player to initiate a series of 
attacks by the predator, properly timed so as to minimize 
the elapsed time required for the predator to catch and 
eat all of the prey fish. The final elapsed time depends 
both on player strategy and random chance. In other words,
as is the case in many games, this game is part strategy 
and part chance.

The prey fish, (shown in red), swim in a large swirling 
cluster. The predator, (shown in blue), swims around the 
cluster, darting into the cluster on command to catch and 
eat as many prey fish as possible during each attack.

When the predator attacks, the prey fish tend to scatter,
breaking up their tight formation and making it more 
difficult for the predator to catch them. However, if the 
predator is allowed to swim around them again for a short 
period following an attack, they will form back into a 
cluster. The attacks should be timed so that the prey fish
are in a reasonably tight cluster at the beginning of each
attack so that multiple prey fish will be caught and 
eaten during the attack. However, allowing too much time 
between attacks is detrimental to minimizing the total 
elapsed time. Thus, the player must make a tradeoff
between elapsed time between attacks and the tightness of
the cluster during the attacks. Another disadvantage of
waiting too long between attacks is explained below.

In addition to some other controls, the GUI provides an 
Attack button and an elapsed-time/kill-count indicator. 
At any point in time, this indicator displays the elapsed 
time in milliseconds when the most recent prey fish was 
caught along with the total number of prey fish that have 
been caught and eaten. The two values are separated by 
a "/" character.

When all of the prey fish have been caught and eaten by 
the predator, the elapsed time indicator shows the time 
in milliseconds required to catch and eat all of the prey
fish.  It also shows the number of prey fish that were 
caught and eaten, which should match one of the player
input values.

Initially, when the player clicks the Start button, the 
predator is not in attack mode. The predator swims around
the school of prey fish encouraging them to bunch up 
together in a smaller and tighter cluster. This behavior 
continues until the player clicks the Attack button, at 
which time the predator enters the attack mode and makes 
an attack on the cluster.

If the player clicks the Attack button too early, or 
doesn't wait long enough between attacks, the prey fish 
will be in a loose cluster, and the attack will yield
very few fish.

If the player waits too long to click the Attack button, 
or waits too long between attacks, the predator will have
spiraled in so close to the prey fish that they will break
formation and begin to scatter, making it difficult for 
the predator to catch a large number of fish during the 
attack. This is the other disadvantage of waiting too 
long that I mentioned above.

The prey fish have a fairly effective defense mechanism
and can do a reasonably good job of escaping the predator.
The final three or four prey fish are usually the most 
difficult to catch.

When the predator is successful in catching a prey fish, 
that fish is removed from the prey-fish population, 
causing the prey-fish population to shrink over time.

Each time the predator is successful in catching a prey 
fish, the program emits an audible beep to provide 
feedback to the player.
 
Even when the predator is not in the attack mode, its 
presence has a significant effect on the behavior of the 
school of prey fish. As the predator swims around the 
school of prey fish, they tend to bunch up into a smaller 
and tighter cluster, but when the predator swims too 
close, the prey fish panic and tend to scatter, breaking
up the tight cluster.

In addition to the elapsed time indicator and the Attack
button, the GUI contains an input text field for the 
number of prey fish that will be in the population plus a 
Start button and a Stop button. The GUI also contains 
check boxes that allow the player to display points only,
direction vectors only, or both for the prey fish. (Only 
the direction vector is displayed for the predator.)

The player specifies the number of randomly-placed prey 
fish that will be in the population and clicks the Start 
button to start the animation. At this point, the prey 
fish swim in a large swirling cluster and the predator 
swims around them encouraging them to form a tighter
cluster  Prey fish motion is random but each fish 
generally tends to spiral toward the center of the 
cluster.

When the user clicks the Attack button, the behavior is 
as described earlier.

The animation continues until the user clicks the Stop 
button. The user can click the Stop button, change any of 
the parameters, and then click Start again to re-start the
game with zero elapsed time and different parameters.

The animation is most impressive when the direction 
vectors are displayed for the prey fish because the 
vectors provide a lot of information about how the prey 
fish are reacting to the predator.

In addition to the school of prey fish and the predator,
the graphical output also shows a large circle drawn
with broken lines. This circle represents the intersection
of a sphere and the x-y plane.

The purpose of the sphere, which is centered on the 
origin, is to provide a soft boundary for keeping the 
prey fish and the predator in the 3D playing field. The 
prey fish and the predator all have a tendency to remain 
inside the sphere, but they may occasionally stray outside
the sphere. If they do, the program code will encourage 
them to return to the 3D playing field inside the sphere.

This game is fully 3D. The prey fish and the predator are
free to swim in any direction in 3D space. The tails on
the prey fish and the predator appear longest when they
are swimming parallel to the x-y plane. As they change 
their angle relative to the x-y plane, the tails appear 
to become shorter and shorter until in some cases, they 
appear not to have a tail at all. This is best observed
by clicking the Stop button just as the fish scatter 
during an attack and freezing the state of the fish in
the 3D world. If you examine the image at that point, you
are likely to see some fish with shorter tails than other
fish.

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

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

class GUI extends JFrame implements ActionListener{

  int hSize = 400;//horizontal size of JFrame.
  int vSize = 450;//vertical size of JFrame
  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.
  int numberPoints = 0;//can be modified by the user.
  JTextField numberPointsField; //user input field.
  Random random = new Random();//random number generator

  //The following collection is used to store the prey
  // objects.
  ArrayList <GM01.Point3D> preyObjects;
  
  //The following collection is used to store the vectors
  // for display.
  ArrayList <GM01.Vector3D> displayVectors;
  
  //The following are used to support user input.
  Checkbox drawPointsBox;//User input field
  Checkbox drawVectorsBox;//User input field.
  JButton attackButton;
  boolean drawPoints = true;
  boolean drawVectors = true;
  
  //The following JTextField is used to display the
  // elapsed time and the number of prey fish that 
  // have been caught and eaten.
  JTextField timer;

  long baseTime;//Used to compute the elapsed time.

  //Used to compute the number of fish caught and eaten.  
  int killCount = 0;

  //Animation takes place while the following is true.
  boolean animate = false;
  
  //Attacks take place while the following is true.
  boolean attack = false;
  
  //Working variables used by the animation code.
  GM01.Vector3D predatorVec;
  GM01.Point3D preyCenter;
  GM01.Point3D predator;
  //----------------------------------------------------//
  
  GUI(){//constructor
  
    //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("100",5);
    JButton startButton = new JButton("Start");
    attackButton = new JButton("Attack");
    JButton stopButton = new JButton("Stop");
    timer = new JTextField("0",5);
    drawPointsBox = new Checkbox("Draw Points",false);
    drawVectorsBox = new Checkbox("Draw Vectors",true);

    //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 component and appropriate labels
    // to the control panel.
    controlPanel.add(new JLabel(" Number Prey Fish"));    
    controlPanel.add(numberPointsField);
    controlPanel.add(drawPointsBox);
    controlPanel.add(drawVectorsBox);
    controlPanel.add(startButton);
    controlPanel.add(attackButton);
    controlPanel.add(stopButton);
    controlPanel.add(timer);

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

    //Instantiate 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());
    
    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    
    //Register this object as an action listener on all
    // three buttons.
    startButton.addActionListener(this);
    attackButton.addActionListener(this);
    stopButton.addActionListener(this);
    
    //Make the drawing color RED at startup.
    g2D.setColor(Color.RED);

  }//end constructor
  //----------------------------------------------------//
  
  //This method is called to respond to a click on any
  // of the three buttons.
  public void actionPerformed(ActionEvent e){

    if(e.getActionCommand().equals("Start") && !animate){
      //Service the Start button.
      
      //Get several user input values.
      numberPoints = Integer.parseInt(
                             numberPointsField.getText());

      if(drawPointsBox.getState()){
        drawPoints = true;
      }else{
        drawPoints = false;
      }//end else
      
      if(drawVectorsBox.getState()){
        drawVectors = true;
      }else{
        drawVectors = false;
      }//end else

      //Initialize some working variables used in the
      // animation process.
      animate = true;
      baseTime = new Date().getTime();
      killCount = 0;
      
      //Enable the Attack button.
      attackButton.setEnabled(true);
      
      //Initialize the text in the timer field.
      timer.setText("0 / 0");
      
      //Cause the run method belonging to the animation
      // thread object to be executed.
      new Animate().start();
    }//end if
    
    
    if(e.getActionCommand().equals("Attack") && animate){
      //Service the Attack button.
      
      //This will cause the predator to attack the prey
      // objects.
      attack = true;
      
      //Point the predator toward the center of the prey
      // fish formation. Reduce the scale factor to less
      // than 1.0 to slow down the attack and make it
      // easier for the prey fish to escape the predator.
      predatorVec = 
               predator.getDisplacementVector(preyCenter).
                                               scale(1.0);
               
      //Disable the Attack button. It will be enabled
      // again when the attack is finished.
      attackButton.setEnabled(false);
    }//end if
    

    if(e.getActionCommand().equals("Stop") && animate){
      //Service the Stop button.
      
      //This will cause the run method to terminate and
      // stop the animation. It will also clear the
      // attack flag so that the next time the animation
      // is started, the predator won't be in the 
      // attack mode.
      animate = false;
      attack = false;
    }//end if

  }//end actionPerformed
  //====================================================//
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the update method to eliminate the default
    // clearing of the Canvas in order to reduce or
    // eliminate the flashing that that is often caused by
    // such default clearing.
    //In this case, it isn't necessary to clear the canvas
    // because the off-screen image is cleared each time
    // it is updated. 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.
    public void update(Graphics g){
      paint(g);//Call the overridden paint method.
    }//end overridden update()
    
    //Override the paint() method. The purpose of the
    // paint method is to display the off-screen image on
    // the screen. This method is called by the update
    // method above.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas
  //====================================================//
  
  //This is an animation thread. The purpose of this
  // animation is to simulate something like a school of
  // prey fish and a predator. The animation behavior
  // is described in the opening comments for the program
  // as a whole.
  class Animate extends Thread{
    //Declare a general purpose variable of type Point3D.
    // It will be used for a variety of purposes.
    GM01.Point3D tempPrey;
    
    //Declare two general purpose variables of type
    // Vector3D. They will be used for a variety of
    // purposes.
    GM01.Vector3D tempVectorA;
    GM01.Vector3D tempVectorB;
    //--------------------------------------------------//
    
    public void run(){
      //This method is executed when start is called on
      // this Thread object.
      //Create a new empty container for the prey objects.
      //Note the use of "Generics" syntax.
      preyObjects = new ArrayList<GM01.Point3D>();
      
      //Create a new empty container for the vectors. The
      // only reason the vectors are saved is so that they
      // can be displayed later
      displayVectors = new ArrayList<GM01.Vector3D>();
      
      //Create a set of prey objects at random locations
      // and store references to the prey objects in the
      // preyObjects container.
      for(int cnt = 0;cnt < numberPoints;cnt++){
        preyObjects.add(new GM01.Point3D(
          new GM01.ColMatrix3D(
                         100*(random.nextDouble()-0.5),
                         100*(random.nextDouble()-0.5),
                         100*(random.nextDouble()-0.5))));
                         
        //Populate the displayVectors collection with
        // dummy vectors.
        displayVectors.add(tempVectorA);
      }//end for loop

      //This object that will be the predator.
      // Position it initially near the top of the screen.
      predator = new GM01.Point3D(
                     new GM01.ColMatrix3D(-100,100,-100));

      //Create a reference point to mark the origin. Among
      // other things, it will be used as the center of a
      // sphere, which in turn will be used to attempt to
      // keep the prey and predator objects from leaving
      // the playing field.
      GM01.Point3D origin = 
            new GM01.Point3D(new GM01.ColMatrix3D(0,0,0));
      
      //Declare some variables that will be used to
      // compute and save the average position of all of
      // the prey objects.
      double xSum = 0;
      double ySum = 0;
      double zSum = 0;


      //This is the animation loop. The value of animate
      // is set to true by the Start button and is set to
      // false by the Stop button. Setting it to false
      // will cause the run method to terminate and stop
      // the animation.
      while(animate){
        //Compute and save the average position of all the
        // prey objects at the beginning of the loop. Save
        // the average position in the Point3D object
        // referred to by preyCenter.
        xSum = 0;
        ySum = 0;
        zSum = 0;

        for(int cnt = 0;cnt < preyObjects.size();cnt++){
          tempPrey = preyObjects.get(cnt);
          xSum += tempPrey.getData(0);
          ySum += tempPrey.getData(1);
          zSum += tempPrey.getData(2);
        }//end for loop
        
        //Construct a reference point at the average
        // position of all the prey objects.
        preyCenter = new GM01.Point3D(
           new GM01.ColMatrix3D(xSum/preyObjects.size(),
                                ySum/preyObjects.size(),
                                zSum/preyObjects.size()));


        //Move all of the prey objects in a way that
        // causes them to spiral toward the preyCenter.
        for(int cnt = 0;cnt < preyObjects.size();cnt++){
          //Stop spiraling toward the center when the
          // population of prey objects contains a
          // single object because there is no center at
          // that point.
          if(preyObjects.size() > 1){
            //Get the next prey object
            tempPrey = preyObjects.get(cnt);
            //Find the displacement vector from this prey
            // object to the preyCenter
            tempVectorA = tempPrey.getDisplacementVector(
                                              preyCenter);
                    
            //Create a vector that is rotated relative to
            // tempVectorA. Note how each component in
            // this new vector is set equal to a different
            // component in tempVectorA. Scale it.
            tempVectorB = new GM01.Vector3D(
              new GM01.ColMatrix3D(
                      tempVectorA.getData(1),
                      tempVectorA.getData(2),
                      tempVectorA.getData(0))).scale(1.2);
                                                       
            //Add the two vectors and move the prey object
            // according to the sum of the vectors. Scale
            // one of the vectors during the addition to
            // adjust the rate at which the object spirals
            // toward the center.
            //Moving the prey object in the direction of
            // the sum of these two vectors produces a
            // motion that causes the prey object to
            // spiral toward the preyCenter instead of
            // simply moving in a straight line toward the
            // preyCenter.
            tempVectorA = 
                  tempVectorA.scale(0.9).add(tempVectorB);
            //Apply an overall scale factor to the sum
            // vector before using it to move the prey
            // object.
            tempPrey = tempPrey.addVectorToPoint(
                                  tempVectorA.scale(0.1));

            //Save a clone of the prey object in its new
            // position. Save a clone instead of the
            // actual object as a safety measure to avoid
            // the possibility of corrupting the object
            // later when the reference variable is used
            // for some other purpose.
            preyObjects.set(cnt,tempPrey.clone());
            
            //Save a normalized version of the direction
            // vector for drawing later. Set the length
            // of the normalized vector to 15 units.
            displayVectors.set(
                 cnt,tempVectorA.normalize().scale(15.0));
          }else{
            //When the population consists of a single
            // prey object, save a dummy direction vector
            // for drawing later. This is necessary to
            // prevent a null pointer exception when the
            // user specifies only one prey object and
            // then clicks the Start button.
            displayVectors.set(
                   cnt,new GM01.Vector3D(
                          new GM01.ColMatrix3D(10,10,0)));
          }//end else
                 
        }//end loop to spiral prey objects toward center.
        

        //Try to keep the prey objects from colliding with
        // one another by moving each prey object away
        // from its close neighbors.
        GM01.Point3D refPrey = null;
        GM01.Point3D testPrey= null;
        for(int row = 0;row < preyObjects.size();row++){
          refPrey = preyObjects.get(row);
          //Compare the position of the reference prey
          // object with the positions of each of the
          // other prey objects.
          for(int col = 0;col < preyObjects.size();col++){
            //Get another prey object for  proximity test.
            testPrey = preyObjects.get(col);
            //Don't test a prey object against itself.
            if(col != row){
              //Get the vector from the refPrey object to
              // the testPrey object.
              tempVectorA = refPrey.
                          getDisplacementVector(testPrey);
              
              //If refPrey is too close to testPrey, move
              // it away from the testPrey object.
              if(tempVectorA.getLength() < 10){
                //Move refPrey away from testPrey by a
                // small amount in the opposite direction.
                refPrey = refPrey.addVectorToPoint(
                         tempVectorA.scale(0.2).negate());

              }//end if on proximity test
            }//end if col != row
          }//end loop on col
          //The refPrey object may or may not have been
          // moved.  Save it anyway.
          preyObjects.set(row,refPrey.clone());
        }//end loop on row


        //Make each prey object react to the predator with
        // a defensive mechanism when the predator
        // approaches the prey object.
        for(int cnt = 0;cnt < preyObjects.size();cnt++){
          tempPrey = preyObjects.get(cnt);
          
          //Get a displacement vector from the prey object
          // to the predator.
          tempVectorA = tempPrey.getDisplacementVector(
                                                predator);

          //If the prey object is within a certain
          // threshold distance from the predator, move
          // the prey object a random distance in the
          // opposite direction. Then test again to see if
          // the prey object is still within another
          // smaller threshold distance. If so, the prey
          // object was not successful in escaping the
          // predator and has been caught and eaten by the
          // predator. Remove the prey object from the
          // population and sound a beep to notify the
          // user of the successful attack by the
          // predator.
          if(tempVectorA.getLength() < 50){
            //The predator is within striking range of the
            // prey object. Make the prey object try to
            // escape by moving a random distance in the
            // opposite direction. The value returned by
            // the random number generator ranges from 0
            // to 1.0.
            tempVectorA = tempVectorA.negate().scale(
                                     random.nextDouble());
            tempPrey = 
                   tempPrey.addVectorToPoint(tempVectorA);
            
            //Check to see if the escape was successful
            // by testing against a smaller threshold
            // distance.
            //Get a new displacement vector from the prey
            // object to the predator.
            tempVectorA = 
                 tempPrey.getDisplacementVector(predator);
            //Decrease or increase the following
            // threshold distance to cause the prey
            // object to be more or less successful in the
            // escape attempt.
            if(tempVectorA.getLength() < 25){
              //Escape was not successful. The predator is
              // still within striking distance of the
              // prey object. Remove the prey object and
              // its direction vector from the population
              // and sound a beep. Also increase the
              // killCount by 1 for purposes of display
              // only.
              tempPrey = preyObjects.remove(cnt);
              displayVectors.remove(cnt);
              Toolkit.getDefaultToolkit().beep();
              killCount++;
              
              //Display the elapsed time in milliseconds
              // since the Start button was clicked along
              // with the number of fish that have been
              // caught and eaten. The value that is
              // displayed is the elapsed time when the
              // most recent prey fish was caught by the
              // predator and is not the total elapsed
              // time since the Start button was clicked.
              // When all prey fish have been caught, the
              // final time that is displayed is the time
              // required for the predator to catch all of
              // the fish in the population.
              timer.setText(
                       "" 
                       + (new Date().getTime() - baseTime)
                       + " / " 
                       + killCount);

            }else{
              //The escape attempt was successful. Restore
              // a clone of the prey object in its new
              // location along with its direction vector
              // to the population.
              preyObjects.set(cnt,tempPrey.clone());
              //Save a normalized version of the direction
              // vector for drawing later.  It will
              // overwrite the previously saved vector and
              // if you watch closely it will show the
              // prey object running away from the
              // predator..
              displayVectors.set(
                 cnt,tempVectorA.normalize().scale(15.0));
            }//end else
          }//end if distance < 50
        }//end for loop on population


        //Deal with prey objects that stray outside the
        // spherical boundary. Give them a nudge back
        // toward the origin.
        for(int cnt = 0;cnt < preyObjects.size();cnt++){
          tempPrey = preyObjects.get(cnt);
          
          //Test to determine if the prey object is
          // outside of a sphere centered on the origin
          // with a radius equal to the maximum dimension
          // on the vertical axis.
          if(tempPrey.getDisplacementVector(origin).
                             getLength() > 0.5*osiHeight){
            //Enable the following statement to get an
            // audible beep each time a prey object goes
            // out of bounds.
            //Toolkit.getDefaultToolkit().beep();
            //Give the prey object a nudge back toward the
            // origin and save a clone of the prey object
            // in its new location.
            tempVectorA = 
                   tempPrey.getDisplacementVector(origin);
            tempPrey = tempPrey.addVectorToPoint(
                                  tempVectorA.scale(0.1));
            preyObjects.set(cnt,tempPrey.clone());
          }//end if prey object is out of bounds
        }//end for loop to process each prey object


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


        //Draw a broken-line circle that represents the
        // intersection of the spherical boundary with the
        // x-y plane. Although the prey objects and the
        // predator can stray outside this sphere, they
        // prefer to be inside the sphere.
        GM01.Point3D tempPointA = new GM01.Point3D(
                   new GM01.ColMatrix3D(osiHeight/2,0,0));
        GM01.Point3D tempPointB;
        //The circle is defined by 39 points around the
        // circumference.
        g2D.setColor(Color.BLACK);
        for(int cnt = 0;cnt < 39;cnt++){
          tempPointB = 
           new GM01.Point3D(new GM01.ColMatrix3D(
           osiHeight/2*Math.cos((cnt*360/39)*Math.PI/180),
           osiHeight/2*Math.sin((cnt*360/39)*Math.PI/180),
           0));
            
          //Connect every third pair of points with a line
          if(cnt%3 == 0){
            new GM01.Line3D(
                         tempPointA,tempPointB).draw(g2D);
          }//end if
          //Save the old point.
          tempPointA = tempPointB;
        }//end for loop
        
        //Draw the final line required to close the circle
        new GM01.Line3D(tempPointA,new GM01.Point3D(
                           new GM01.ColMatrix3D(
                             osiHeight/2,0,0))).draw(g2D);


        //Restore the drawing color.
        g2D.setColor(Color.RED);
        //Draw the objects in the preyObjects container
        // and the vectors in the displayVectors
        // container.
        for(int cnt = 0;cnt < preyObjects.size();cnt++){
          tempPrey = preyObjects.get(cnt);
          if(drawPoints){
            tempPrey.draw(g2D);//draw circle around point
          }//end if
          
          if(drawVectors){
            //Draw the vector with its tail at the point.
            displayVectors.get(cnt).draw(g2D,tempPrey);
          }//end if
        }//end for loop
        
        
        //When the predator is not in attack mode, cause
        // it to slowly circle the cluster of prey
        // objects.
        if(!attack){
          //Get a displacement vector pointing from the
          // predator to the preyCenter.
          predatorVec = 
               predator.getDisplacementVector(preyCenter);
                  
          //Create a vector that is rotated relative to
          // predatorVec. Note how each component in
          // this new vector is set equal to a different
          // component in predatorVec
          tempVectorB = new GM01.Vector3D(
            new GM01.ColMatrix3D(
                     predatorVec.getData(1),
                     predatorVec.getData(2),
                     predatorVec.getData(0))).scale(0.15);
                                                     
          //Scale predatorVec and add the two vectors.
          // Then move the predator according to the sum
          // of the vectors.
          //Moving the prey object in the direction of
          // the sum of these two vectors produces a
          // motion that causes the predator to
          // spiral toward the preyCenter instead of
          // simply moving in a straight line toward the
          // preyCenter. The scale factors control the
          // relative motion between the two directions,
          // and are fairly sensitive.
          predatorVec = 
                predatorVec.scale(0.095).add(tempVectorB);
          
          predator = predator.addVectorToPoint(
                                  predatorVec.scale(1.0));

        }else{//attack is true
          //Predator is in attack mode now. Stay in attack
          // mode using the same displacement vector until
          // the predator traverses the entire playing
          // field. This displacement vector originally
          // pointed toward the preyCenter and was created
          // in the actionPerformed method in response to
          // a click on the Attack button. In other words,
          // even though the prey fish scatter, the
          // predator is constrained to move in a straight
          // line across the playing field once an attack
          // is begun. An interesting update might be to
          // allow the predator to adjust its direction
          // as the prey fish scatter and the location of
          // preyCenter changes during the traversal
          // across the playing field.
          predator = predator.addVectorToPoint(
                                 predatorVec.scale(0.25));

          //Check to see if the predator is outside the
          // spherical boundary that defines the playing
          // field.
          if(predator.getDisplacementVector(origin).
                             getLength() > 0.5*osiHeight){
            //Shift out of attack mode and start circling
            // the prey fish again.
            attack = false;
            attackButton.setEnabled(true);
          }//end if
        }//end else


        //Set the color to BLUE and draw the predator and
        // its displacement vector.
        g2D.setColor(Color.BLUE);
        //Enable the following statement to draw a circle
        // around the point that represents the predator.
        //predator.draw(g2D);
        
        //Draw the predator's vector.
        predatorVec.normalize().scale(15.0).draw(
                                            g2D,predator);
        g2D.setColor(Color.RED);//restore red color
        
        //Copy the off-screen image to the canvas and then
        // do it all again.
        myCanvas.repaint();
        
        //Insert a time delay. Change the sleep time to
        // speed up or slow down the animation. 
        try{
          Thread.currentThread().sleep(166);
        }catch(Exception e){
          e.printStackTrace();
        }//end catch
      }//end animation loop
    }//end run method
  }//end inner class named Animate
  //====================================================//

}//end class GUI

/*GM01test04.java 
Copyright 2008, R.G.Baldwin
Revised 02/25/08.

This animation program is designed to test many of the 2D
features of the GM01 game-math library.

The animation is generally based on the idea of a 
flocking behavior similar to that exhibited by birds.

A set of Point2D objects is created with random locations.
An additional Point2D object known at the target is also 
created. The target is drawn in red while the pursuers
are drawn in black.

An algorithm is executed that attempts to cause the points
to chase the target without colliding with one another.
Even though the algorithm causes the points to chase the 
target, it also tries to keep the points from colliding 
with the target.

A GUI is provided that contains an input text field for 
the number of points plus a Start button and a Stop
button. The GUI also contains check boxes that allow the 
user to elect to display points only, direction vectors 
only, or both. (The point and the direction vector is
always displayed for the target.)

The user specifies the number of randomly-placed points 
and clicks the Start button, at which time the animation
begins and the points start chasing the target.  Target 
motion is random. The animation continues until the user 
clicks the Stop button. The user can click the Stop 
button, change the number of points, and then click Start 
again to re-start the animation with a different number
of points chasing the target.

The algorithm seems to cause the points to come together 
and fly in formation while chasing the target. The most 
common formation is hexagonal but sometimes triangles and
incomplete hexagons also appear. I have no explanation for
this behavior. The tendency to fly in formation is more
visually obvious when only the points are displayed.

On the other hand, the animation is most impressive when 
the direction vectors are displayed, with or without 
points, because the vectors illustrate the dogged 
determination and undying focus that the pursuers maintain
while chasing the target.

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

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

class GUI extends JFrame implements ActionListener{

  int hSize = 400;//horizontal size of JFrame.
  int vSize = 400;//vertical size of JFrame
  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.
  int numberPoints = 0;//can be modified by the user.
  JTextField numberPointsField; //user input field.
  Random random = new Random();//random number generator

  //The following collection is used to store the points.
  ArrayList <GM01.Point2D> points;
  
  //The following collection is used to store the vectors
  // for display.
  ArrayList <GM01.Vector2D> vectors;
  
  //The following are used to support user input.
  Checkbox drawPointsBox;//User input field
  Checkbox drawVectorsBox;//User input field.
  boolean drawPoints = true;
  boolean drawVectors = true;
  
  //Animation takes place while the following is true.
  boolean animate = false;
  //----------------------------------------------------//
  
  GUI(){//constructor
  
    //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",5);
    JButton startButton = new JButton("Start");
    JButton stopButton = new JButton("Stop");
    drawPointsBox = new Checkbox("Draw Points",true);
    drawVectorsBox = new Checkbox("Draw Vectors",true);

    //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 component and appropriate labels
    // to the control panel.
    controlPanel.add(new JLabel(" Number Points"));    
    controlPanel.add(numberPointsField);
    controlPanel.add(drawPointsBox);
    controlPanel.add(drawVectorsBox);
    controlPanel.add(startButton);
    controlPanel.add(stopButton);

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

    //Instantiate 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());
    
    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    
    //Register this object as an action listener on the
    // startButton and the stopButton
    startButton.addActionListener(this);
    stopButton.addActionListener(this);
    
  }//end constructor
  //----------------------------------------------------//
  
  //This method is called to respond to a click on the
  // startButton or the stopButton.
  public void actionPerformed(ActionEvent e){

    if(e.getActionCommand().equals("Start") && !animate){
      numberPoints = Integer.parseInt(
                             numberPointsField.getText());

      if(drawPointsBox.getState()){
        drawPoints = true;
      }else{
        drawPoints = false;
      }//end else
      
      if(drawVectorsBox.getState()){
        drawVectors = true;
      }else{
        drawVectors = false;
      }//end else

      animate = true;
      new Animate().start();
    }//end if
    
    if(e.getActionCommand().equals("Stop") && animate){
      //This will cause the run method to terminate and
      // stop the animation.
      animate = false;
    }//end if

  }//end actionPerformed
  //====================================================//
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the update method to eliminate the default
    // clearing of the Canvas in order to reduce or
    // eliminate the flashing that that is often caused by
    // such default clearing.
    //In this case, it isn't necessary to clear the canvas
    // because the off-screen image is cleared each time
    // it is updated. 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.
    public void update(Graphics g){
      paint(g);//Call the overridden paint method.
    }//end overridden update()
    
    //Override the paint() method. The purpose of the
    // paint method is to display the off-screen image on
    // the screen. This method is called by the update
    // method above.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas
  //====================================================//
  
  //This is an animation thread.
  class Animate extends Thread{
    //Declare a general purpose variable of type Point2D.
    // It will be used for a variety of purposes.
    GM01.Point2D tempPoint;
    
    //Declare a general purpose variable of type Vector2D.
    // It will be used for a variety of purposes.
    GM01.Vector2D tempVector;
    
    public void run(){
      //This method is executed when start is called on
      // this thread.
      //Create a new empty container for the points.
      points = new ArrayList<GM01.Point2D>();
      
      //Create a new empty container for the vectors.
      vectors = new ArrayList<GM01.Vector2D>();
      
      //Create a set of Point objects at random locations
      // and store references to the points in the
      // ArrayList object..
      for(int cnt = 0;cnt < numberPoints;cnt++){
        points.add(new GM01.Point2D(
          new GM01.ColMatrix2D(
                         100*(random.nextDouble()-0.5),
                         100*(random.nextDouble()-0.5))));
                         
        //Populate vectors collection with dummy vectors.
        vectors.add(tempVector);
      }//end for loop

      //Create a Point2D object that will be the target
      // that will be chased by the other Point2D objects.
      GM01.Point2D target = new GM01.Point2D(
          new GM01.ColMatrix2D(
                          100*(random.nextDouble()-0.5),
                          100*(random.nextDouble()-0.5)));
  
      //Create a Vector2D object that will be used to
      // control the motion of the target.
      GM01.Vector2D targetVec = new GM01.Vector2D(
             new GM01.ColMatrix2D(
               100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5))).scale(0.3);

      //Create a reference point to mark the origin.
      GM01.Point2D zeroPoint = 
              new GM01.Point2D(new GM01.ColMatrix2D(0,0));

      //Declare a variable that will be used to control
      // the update frequency of the target vector.
      int animationLoopCounter = 0;
      
      //This is the animation loop. The value of animate
      // is set to true by the Start button and is set to
      // false by the Stop button. Setting it to false
      // will cause the run method to terminate and stop
      // the animation.
      while(animate){
        animationLoopCounter++;
        
        //Try to keep the points from colliding with one
        // another.  Note, however, that this algorithm
        // is far from perfect in accomplishing that.
        for(int row = 0;row < points.size();row++){
          for(int col = 0;col < points.size();col++){
            GM01.Point2D refPoint = points.get(row);
            GM01.Point2D testPoint = points.get(col);
            
            if(col != row){
              //Get the distance of the testPoint from the
              // refPoint.
              tempVector = testPoint.
                          getDisplacementVector(refPoint);
              
              if(tempVector.getLength() < 25){
                //Modify testPoint to move it away from
                // the refPoint and save the modified
                // point.
                tempVector = tempVector.negate();
                tempPoint = testPoint.addVectorToPoint(
                                   tempVector.scale(0.1));
                points.set(col,tempPoint.clone());
              }else{
                //Do nothing.
              }//end else
            }//end if col != row
          }//end loop on col
        }//end loop on row

        //Move all of the points toward the target but try
        // to keep them separated from the target.
        for(int cnt = 0;cnt < points.size();cnt++){
          //Get the next point.
          tempPoint = points.get(cnt);
          //Find the distance from this point to the
          // target.
          tempVector = 
                  tempPoint.getDisplacementVector(target);
          if(tempVector.getLength() < 10){
            //Modify the point to move it away from the
            // target and save the modified point.
            tempVector = tempVector.negate();
            tempPoint = tempPoint.addVectorToPoint(
                                   tempVector.scale(0.1));
            //Save the modified point.
            points.set(cnt,tempPoint.clone());
          }else{
            //Modify the point to move it toward the
            // target and save the modified point.
            tempPoint = tempPoint.addVectorToPoint(
                                   tempVector.scale(0.1));
            points.set(cnt,tempPoint.clone());
          }//end else
          
          //Save a normalized version of the direction
          // vector for drawing later.
          vectors.set(
                  cnt,tempVector.normalize().scale(15.0));
          
        }//end for loop
        
        //Insert a delay.
        try{
          Thread.currentThread().sleep(166);
        }catch(Exception e){
          e.printStackTrace();
        }//end catch
        
        //Erase the screen
        g2D.setColor(Color.WHITE);
        GM01.fillRect(g2D,-osiWidth/2,osiHeight/2,
                                      osiWidth,osiHeight);
        g2D.setColor(Color.BLACK);
        
        //Draw the points and the vectors in the arrayList
        // objects.
        for(int cnt = 0;cnt < numberPoints;cnt++){
          tempPoint = points.get(cnt);
          if(drawPoints){
            tempPoint.draw(g2D);
          }//end if
          
          if(drawVectors){
            tempVector = vectors.get(cnt);
            tempVector.draw(g2D,tempPoint);
          }//end if
        }//end for loop
        
        
        //Cause the targets movements to be slightly less
        // random by using the same vector for several
        // successive movements
        if(animationLoopCounter%10 == 0){
          //Get a new vector
          targetVec = new GM01.Vector2D(
              new GM01.ColMatrix2D
               (100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5))).scale(0.3);
        }//else use the same vector again.
                               
        //Test to see if this displacement vector will
        // push the target outside the limit. If so,
        // modify the vector to send the target back
        // toward the origin.
        if(target.getDisplacementVector(zeroPoint).
                              getLength() > 0.4*osiWidth){
          targetVec = target.getDisplacementVector(
                                    zeroPoint).scale(0.1);

        }//end if
   
        //Modify the location of the target point.
        target = target.addVectorToPoint(targetVec);
        
        //Set the color to RED and draw the target and its
        // vector.
        g2D.setColor(Color.RED);
        target.draw(g2D);
        targetVec.normalize().scale(15.0).draw(
                                              g2D,target);
        
        g2D.setColor(Color.BLACK);
        
        myCanvas.repaint();
      }//end while loop
    }//end run
  }//end inner class named Animate
  //====================================================//

}//end class GUI

/*GM01test03.java 
Copyright 2008, R.G.Baldwin
Revised 02/25/08.

This is a 3D update from the 2D version named GM01test04.
Basically all that was required to perform the update was
to specify 3D classes from the game-math library in place
of the 2D classes used in the 2D version. Virtually 
everything else took care of itself.

The visual behavior of this 3D version is more realistic 
than the 2D version. This is particularly true when the 
target gets in the middle of the pursuers and the display 
is showing both points and vectors. In this 3D version, 
a pursuer is free to swing around in any plane as the 
target passes by whereas in the 2D version, a pursuer is
constrained to swing around only in the plane of the 
screen. That causes the motion to be less fluid. This is
best demonstrated with only one pursuer because that makes
it easy to see the behavior of an individual pursuer.

One thing that I did notice, is that unlike the 2D 
version, the pursuers in this 3D version don't seem to 
have a tendency to form up and fly in formation while 
chasing the target. This may be because they have more 
options in terms of avoiding collisions while giving 
chase, but that is pure speculation since I don't know
why they tend to fly in formation in the 2D version.

This animation program is designed to test many of the 3D
features of the GM01 game-math library.

The animation is generally based on the idea of a 
flocking behavior similar to that exhibited by birds.

A set of Point3D objects is created with random locations.
An additional Point3D object known at the target is also 
created. The target is drawn in red while the pursuers
are drawn in black.

An algorithm is executed that attempts to cause the points
to chase the target without colliding with one another.
Even though the algorithm causes the points to chase the 
target, it also tries to keep the points from colliding 
with the target.

A GUI is provided that contains an input text field for 
the number of points plus a Start button and a Stop
button. The GUI also contains check boxes that allow the 
user to elect to display points only, direction vectors 
only, or both. (Both the point and the direction vector
are always displayed for the target.)

The user specifies the number of randomly-placed points 
and clicks the Start button, at which time the animation
begins and the points start chasing the target.  Target 
motion is random. The animation continues until the user 
clicks the Stop button. The user can click the Stop 
button, change the number of points, and then click Start 
again to re-start the animation with a different number
of points chasing the target.

The animation is most impressive when the direction 
vectors are displayed, with or without points, because the
vectors illustrate the dogged determination and undying 
focus that the pursuers maintain while chasing the target.

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

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

class GUI extends JFrame implements ActionListener{

  int hSize = 400;//horizontal size of JFrame.
  int vSize = 400;//vertical size of JFrame
  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.
  int numberPoints = 0;//can be modified by the user.
  JTextField numberPointsField; //user input field.
  Random random = new Random();//random number generator

  //The following collection is used to store the points.
  ArrayList <GM01.Point3D> points;
  
  //The following collection is used to store the vectors
  // for display.
  ArrayList <GM01.Vector3D> vectors;
  
  //The following are used to support user input.
  Checkbox drawPointsBox;//User input field
  Checkbox drawVectorsBox;//User input field.
  boolean drawPoints = true;
  boolean drawVectors = true;

  //Animation takes place while the following is true.
  boolean animate = false;
  //----------------------------------------------------//
  
  GUI(){//constructor
  
    //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",5);
    JButton startButton = new JButton("Start");
    JButton stopButton = new JButton("Stop");
    drawPointsBox = new Checkbox("Draw Points",true);
    drawVectorsBox = new Checkbox("Draw Vectors",true);

    //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 component and appropriate labels
    // to the control panel.
    controlPanel.add(new JLabel(" Number Points"));    
    controlPanel.add(numberPointsField);
    controlPanel.add(drawPointsBox);
    controlPanel.add(drawVectorsBox);
    controlPanel.add(startButton);
    controlPanel.add(stopButton);

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

    //Instantiate 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());
    
    //Translate the origin to the center.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    
    //Register this object as an action listener on the
    // startButton and the stopButton
    startButton.addActionListener(this);
    stopButton.addActionListener(this);

  }//end constructor
  //----------------------------------------------------//
  
  //This method is called to respond to a click on the
  // startButton or the stopButton.
  public void actionPerformed(ActionEvent e){

    if(e.getActionCommand().equals("Start") && !animate){
      numberPoints = Integer.parseInt(
                             numberPointsField.getText());

      if(drawPointsBox.getState()){
        drawPoints = true;
      }else{
        drawPoints = false;
      }//end else
      
      if(drawVectorsBox.getState()){
        drawVectors = true;
      }else{
        drawVectors = false;
      }//end else

      animate = true;
      new Animate().start();
    }//end if
    
    if(e.getActionCommand().equals("Stop") && animate){
      //This will cause the run method to terminate and
      // stop the animation.
      animate = false;
    }//end if

  }//end actionPerformed
  //====================================================//
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the update method to eliminate the default
    // clearing of the Canvas in order to reduce or
    // eliminate the flashing that that is often caused by
    // such default clearing.
    //In this case, it isn't necessary to clear the canvas
    // because the off-screen image is cleared each time
    // it is updated. 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.
    public void update(Graphics g){
      paint(g);//Call the overridden paint method.
    }//end overridden update()
    
    //Override the paint() method. The purpose of the
    // paint method is to display the off-screen image on
    // the screen. This method is called by the update
    // method above.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()

  }//end inner class MyCanvas
  //====================================================//
  
  //This is an animation thread.
  class Animate extends Thread{
    //Declare a general purpose variable of type Point3D.
    // It will be used for a variety of purposes.
    GM01.Point3D tempPoint;
    
    //Declare a general purpose variable of type Vector3D.
    // It will be used for a variety of purposes.
    GM01.Vector3D tempVector;
    
    public void run(){
      //This method is executed when start is called on
      // this thread.
      //Create a new empty container for the points.
      points = new ArrayList<GM01.Point3D>();
      
      //Create a new empty container for the vectors.
      vectors = new ArrayList<GM01.Vector3D>();
      
      //Create a set of Point objects at random locations
      // and store references to the points in the
      // ArrayList object..
      for(int cnt = 0;cnt < numberPoints;cnt++){
        points.add(new GM01.Point3D(
          new GM01.ColMatrix3D(
                         100*(random.nextDouble()-0.5),
                         100*(random.nextDouble()-0.5),
                         100*(random.nextDouble()-0.5))));
                         
        //Populate vectors collection with dummy vectors.
        vectors.add(tempVector);
      }//end for loop

      //Create a Point3D object that will be the target
      // that will be chased by the other Point3D objects.
      GM01.Point3D target = new GM01.Point3D(
          new GM01.ColMatrix3D(
                          100*(random.nextDouble()-0.5),
                          100*(random.nextDouble()-0.5),
                          100*(random.nextDouble()-0.5)));
  
      //Create a Vector3D object that will be used to
      // control the motion of the target.
      GM01.Vector3D targetVec = new GM01.Vector3D(
             new GM01.ColMatrix3D(
               100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5))).scale(0.3);

      //Create a reference point to mark the origin.
      GM01.Point3D zeroPoint = 
            new GM01.Point3D(new GM01.ColMatrix3D(0,0,0));

      //Declare a variable that will be used to control
      // the update frequency of the target vector.
      int animationLoopCounter = 0;
      
      //This is the animation loop. The value of animate
      // is set to true by the Start button and is set to
      // false by the Stop button. Setting it to false
      // will cause the run method to terminate and stop
      // the animation.
      while(animate){
        animationLoopCounter++;

        //Try to keep the points from colliding with one
        // another.
        for(int row = 0;row < points.size();row++){
          for(int col = 0;col < points.size();col++){
            GM01.Point3D refPoint = points.get(row);
            GM01.Point3D testPoint = points.get(col);
            
            if(col != row){
              //Get the distance of the testPoint from the
              // refPoint.
              tempVector = testPoint.
                          getDisplacementVector(refPoint);
              
              if(tempVector.getLength() < 25){
                //Modify testPoint to move it away from
                // the refPoint and save the modified
                // point.
                tempVector = tempVector.negate();
                tempPoint = testPoint.addVectorToPoint(
                                   tempVector.scale(0.1));
                points.set(col,tempPoint.clone());
              }else{
                //Do nothing.
              }//end else
            }//end if col != row
          }//end loop on col
        }//end loop on row

        //Move all of the points toward the target but try
        // to keep them separated from the target.
        for(int cnt = 0;cnt < points.size();cnt++){
          //Get the next point.
          tempPoint = points.get(cnt);
          //Find the distance from this point to the
          // target.
          tempVector = 
                  tempPoint.getDisplacementVector(target);
          if(tempVector.getLength() < 10){
            //Modify the point to move it away from the
            // target and save the modified point.
            tempVector = tempVector.negate();
            tempPoint = tempPoint.addVectorToPoint(
                                   tempVector.scale(0.1));
            //Save the modified point.
            points.set(cnt,tempPoint.clone());
          }else{
            //Modify the point to move it toward the
            // target and save the modified point.
            tempPoint = tempPoint.addVectorToPoint(
                                   tempVector.scale(0.2));
            points.set(cnt,tempPoint.clone());
          }//end else
          
          //Save a normalized version of the direction
          // vector for drawing later.
          vectors.set(
                  cnt,tempVector.normalize().scale(15.0));
                  
        }//end for loop
  
        //Insert a delay.
        try{
          Thread.currentThread().sleep(166);
        }catch(Exception e){
          e.printStackTrace();
        }//end catch
        
        //Erase the screen
        g2D.setColor(Color.WHITE);
        GM01.fillRect(g2D,-osiWidth/2,osiHeight/2,
                                      osiWidth,osiHeight);
        g2D.setColor(Color.BLACK);
        
        //Draw the points and the vectors in the arrayList
        // objects.
        for(int cnt = 0;cnt < numberPoints;cnt++){
          tempPoint = points.get(cnt);
          if(drawPoints){
            tempPoint.draw(g2D);
          }//end if
          
          if(drawVectors){
            tempVector = vectors.get(cnt);
            tempVector.draw(g2D,tempPoint);
          }//end if
        }//end for loop
        
        //Cause the targets movements to be slightly less
        // random by using the same vector for several
        // successive movements
        if(animationLoopCounter%10 == 0){
          //Get a new vector
          targetVec = new GM01.Vector3D(
              new GM01.ColMatrix3D
               (100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5),
               100*(random.nextDouble()-0.5))).scale(0.3);
        }//else use the same vector again.
                               
        //Test to see if this displacement vector will
        // push the target outside the limit. If so,
        // modify the vector to send the target back
        // toward the origin.
        if(target.getDisplacementVector(zeroPoint).
                              getLength() > 0.4*osiWidth){
          targetVec = target.getDisplacementVector(
                                    zeroPoint).scale(0.1);
        }//end if
   
        //Modify the location of the target point.
        target = target.addVectorToPoint(targetVec);
        
        //Set the color to RED and draw the target and its
        // displacement vector.
        g2D.setColor(Color.RED);
        target.draw(g2D);
        targetVec.normalize().scale(15.0).draw(
                                              g2D,target);

        g2D.setColor(Color.BLACK);
        
        myCanvas.repaint();
      }//end while loop
    }//end run
  }//end inner class named Animate
  //====================================================//

}//end class GUI

/*StringArt04.java 
Copyright 2008, R.G.Baldwin
Revised 03/03/08

This program animates the behavior of the earlier program
named StringArt03.  See the comments at the beginning of
that program for a description of both programs. The only
significant difference in the behavior of the two 
programs is that this program slows the rotation process 
down so that the user can see it happening in real time.
Of course, quite a few changes were required to convert
the program from a static program to an animated program.

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

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

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.
  
  GM01.Point3D anchorPoint;
//  boolean animate = false;
  
  //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
  
    //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("Animate");

    //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());
    
    
    //Translate the origin to the center of the off-screen
    // image.
    GM01.translate(g2D,0.5*osiWidth,-0.5*osiHeight);
    
    //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 draw the appropriate
  // material onto the off-screen image.
  void drawOffScreen(Graphics2D g2D){
    //Erase the off-screen image and draw new axes.
    setCoordinateFrame(g2D);

    //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, in x-y plane
    // Rotate around x, in y-z plane
    // Rotate around y, in x-z plane
    GM01.ColMatrix3D angles = new GM01.ColMatrix3D(
                         zRotation,xRotation,yRotation);
                           
    //The following code causes the anchor point to be
    // drawn and the points in the array to be rotated.
    g2D.setColor(Color.BLACK);
    anchorPoint.draw(g2D);
    for(int cnt = 0;cnt < numberPoints;cnt++){
      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 draw orthogonal
  // 3D axes on the image that intersect at the origin.
  private void setCoordinateFrame(
                        Graphics2D g2D){
    
    //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 point values.
    xAnchorPoint = 
          Double.parseDouble(xAnchorPointField.getText());
    yAnchorPoint = 
          Double.parseDouble(yAnchorPointField.getText());
    zAnchorPoint = 
          Double.parseDouble(zAnchorPointField.getText());


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


    //Instantiate a new array object with a length
    // that matches the new value for numberPoints.    
    points = new GM01.Point3D[numberPoints];
    
    //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 the 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));
    }//end for loop that creates the points

    //Spawn an animation thread
    Animate animate = new Animate();
    animate.start();
    
  }//end actionPerformed
  //====================================================//
  
  
  //This is an inner class of the GUI class.
  class MyCanvas extends Canvas{
    //Override the update method to eliminate the default
    // clearing of the Canvas in order to reduce or
    // eliminate the flashing that that is often caused by
    // such default clearing.
    //In this case, it isn't necessary to clear the canvas
    // because the off-screen image is cleared each time
    // it is updated. 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.
    public void update(Graphics g){
      paint(g);//Call the overridden paint method.
    }//end overridden update()
    
    //Override the paint() method. The purpose of the
    // paint method is to display the off-screen image on
    // the screen. This method is called by the update
    // method above.
    public void paint(Graphics g){
      g.drawImage(osi,0,0,this);
    }//end overridden paint()
  }//end inner class MyCanvas
  //====================================================//
  
  //This is an animation thread.
  class Animate extends Thread{
    public void run(){
      //Compute incremental rotation values.
      int steps = 100;//Number of steps in the animation.
      double zRotationInc = zRotation/steps;
      double xRotationInc = xRotation/steps;
      double yRotationInc = yRotation/steps;
      
      //Do the animated rotation in three distinct stages,
      // rotating around one axis during each stage.
      for(int axis = 0;axis < 3;axis++){
        for(int cnt = 0;cnt < steps;cnt++){
          //Select the axis about which the image will
          // be rotated during this step..
          if(axis % 3 == 0){
            zRotation = zRotationInc;
            xRotation = 0;
            yRotation = 0;
          }else if(axis % 3 == 1){
            zRotation = 0;
            xRotation = xRotationInc;
            yRotation = 0;
          }else if(axis % 3 == 2){
            zRotation = 0;
            xRotation = 0;
            yRotation = yRotationInc;
          }//end else

          //Draw a new off-screen image based on
          // user input values.
          drawOffScreen(g2D);
          //Copy off-screen image to canvas.
          myCanvas.repaint();

          //Sleep for ten milliseconds.
          try{
            Thread.currentThread().sleep(10);
          }catch(InterruptedException ex){
            ex.printStackTrace();
          }//end catch
        }//end for loop
      }//end for loop on axis
    }//end run
  }//end inner class named Animate
  //====================================================//
    
}//end class GUI