// GeometricAlgebra Java package file
   // Current version
   // Go to ... http://sinai.mech.fukui-u.ac.jp/gcj/software/KamiWaAi/index.html
   // Copyright (C) 2003, Eckhard M.S. Hitzer
   //
   // This library is free software; you can redistribute it and/or
   // modify it under the terms of the GNU Lesser General Public
   // License as published by the Free Software Foundation; either
   // version 2.1 of the License, or any later version.
  //
  // This library is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  // Lesser General Public License for more details.
  //
  // You should have received a copy of the GNU Lesser General Public
  // License along with this library; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  // Go to ... http://www.gnu.org/copyleft/lesser.html
  // 
  // hitzer@mech.fukui-u.ac.jp
  // 
  // Department of Mechanical Engineering, Fukui University
  // 3-9-1 Bunkyo, 910-8507 Fukui, Japan
  // 
  //
  //
  // It the personal wish of E.M.S. Hitzer,
  // that you never use this software for infringing human dignity:
  //
  // "God created man in his own image,
  // in the image of God he created him;
  // male and female he created them.
  // [The Bible, Genesis chapter 1 verse 27]
  //
  //
  //
  // 
  // File Circle.java
  // 2003-5-1
  package net.sourceforge.kamiwaai.geometricalgebra;
  import java.awt.BasicStroke;
  import java.awt.Color;
  import java.awt.Graphics;
  import java.awt.Graphics2D;
  import java.awt.geom.GeneralPath;
  public class Circle extends GeometricObject{
  	//	private MultiVector[] basepoints = new MultiVector[3];
  	// The default color of circles will be red.
  	private Color color = Color.red;
  	public Circle(MultiVector L3) {
  		L = L3;
  	}
  	public Circle(PointC point1, PointC point2, PointC point3) {
  		L = point1.getMultiVector().OutProd(point2.getMultiVector())
  				.OutProd(point3.getMultiVector());
  	}
  	public double radius() {
  		double r2 = (L.ScProd(L))
  				* (-1.0 / (n.OutProd(L).ScProd(n.OutProd(L))));
  		double r = Math.sqrt(r2);
  		return r;
  	}
  	public MultiVector Center() {
  		// Gives the full conformal MultiVector for the center of the circle
  		Circle LC = new Circle(L);
  		MultiVector low = n.OutProd(L).mult(I).multSc(-1.0);
  		double llow = low.ScProd(low);
  		MultiVector Low = low.multSc(1.0 / llow); // inverse of low
  		MultiVector Result = L.mult(I).mult(Low);
  		double r = LC.radius();
  		MultiVector Cent = Result.add(n.multSc(0.5 * r * r));
  		return Cent;
  	}
  
  	public double[] center() {
  		// Gives the 3D Euclidean vector of the center of the circle
  		double[] cvector = new double[3];
  		Circle LC = new Circle(L);
  		cvector[0] = LC.Center().get3DEuclidianPoint()[0];
  		cvector[1] = LC.Center().get3DEuclidianPoint()[1];
  		cvector[2] = LC.Center().get3DEuclidianPoint()[2];
  		return cvector;
  	}
  	public MultiVector Cplane() {
  		// Gives the 3D Euclidean bivector as part of the conformal algbra
  		// stripping away the non-Euclidean components
  		MultiVector ICp = L.OutProd(n).Rcontract(N);
  		MultiVector IC = ICp.normalize();
  		return IC;
  	}
  	public MultiVector generator(int inc) {
  		// Gives the Motor (MuliVector that rotates a given
  		// angle increment 2pi/inc about the circle center)
  		int UP = inc;
  		double angle = 2 * Math.PI / UP;
  		MultiVector cv, IC, Tc, Tcr, R, D;
  		Circle LC = new Circle(L);
  		cv = LC.Center().OutProd(N).mult(N); // Euclidean 3D center vector.
 		// Translation operator
 		Tc = One.add(n.mult(cv).multSc(0.5));
 		Tcr = Tc.reverse();
 		IC = LC.Cplane();
 		// Rotation rotor R:
 		R = One.multSc(Math.cos(0.5 * angle)).add(
 				IC.multSc(Math.sin(0.5 * angle)));
 		// Operator for rotation about the circle center by angle increment.
 		D = Tc.mult(R).mult(Tcr);
 		return D;
 	}
 	public MultiVector PonC() {
 		// Gives back one point on the circle
 		MultiVector IC, rv, rad, Trad, Tradr, ponc;
 		double r;
 		Circle LC = new Circle(L);
 		IC = LC.Cplane();
 		rv = e1.Lcontract(IC).add(e2.Lcontract(IC));
 		r = LC.radius();
 		rad = rv.multSc(r / (rv.magnitude()));
 		// Translation operator from the center to a point on the cirlce itself
 		Trad = One.add(n.mult(rad).multSc(0.5));
 		Tradr = Trad.reverse();
 		ponc = Trad.mult(LC.Center()).mult(Tradr);
 		return ponc;
 	}
 	public double[][] cpoints(int inc) {
 		// Gives back an array of inc Euclidean 3D points on the circle
 		double[][] points = new double[inc][3];
 		MultiVector D, Dr, Cpoint;
 		int f, num;
 		Circle LC = new Circle(L);
 		num = inc;
 		D = LC.generator(num);
 		Dr = D.reverse();
 		Cpoint = LC.PonC();
 		points[0][0] = Cpoint.get3DEuclidianPoint()[0];
 		points[0][1] = Cpoint.get3DEuclidianPoint()[1];
 		points[0][2] = Cpoint.get3DEuclidianPoint()[2];
 		for (f = 1; f < num; f++) {
 			Cpoint = D.mult(Cpoint).mult(Dr);
 			// The Euclidean 3D vector points on the circle are:
 			points[f][0] = Cpoint.get3DEuclidianPoint()[0];
 			points[f][1] = Cpoint.get3DEuclidianPoint()[1];
 			points[f][2] = Cpoint.get3DEuclidianPoint()[2];
 		}
 		return points;
 	}
 	public void setColor(Color c) {
 		color = c;
 	}
 	public void draw(Graphics g) {
 		int nump = 500;
 		double[][] CPs;
 		CPs = cpoints(nump);
 		Graphics2D g2 = (Graphics2D) g;
 		g2.setColor(color);
 		g2.setStroke(new BasicStroke(1.0f));
 		// Create a circle using a general path object
 		GeneralPath p = new GeneralPath();
 		p.moveTo((float) CPs[0][0], (float) CPs[0][1]);
 		for (int m = 1; m < nump; m++) {
 			p.lineTo((float) CPs[m][0], (float) CPs[m][1]);
 		}
 		p.closePath();
 		// render the circle's path
 		g2.draw(p);
 	}
 	public void drawZ(Graphics g) {
 		int nump = 60;
 		double[][] CPs;
 		CPs = cpoints(nump);
 		Graphics2D g2 = (Graphics2D) g;
 		g2.setColor(color);
 		g2.setStroke(new BasicStroke(1.0f));
 		// Create a circle using a general path object
 		GeneralPath p = new GeneralPath();
 		p.moveTo((float) CPs[0][2], (float) CPs[0][1]);
 		for (int m = 1; m < nump; m++) {
 			p.lineTo((float) CPs[m][2], (float) CPs[m][1]);
 		}
 		p.closePath();
 		// render the circle's path
 		g2.draw(p);
 	}
 
 }