// 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 Line.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 Line extends GeometricObject {
  	//private MultiVector[] basepoints = new MultiVector[2];
  	// The default color of lines will be cyan.
  	private Color color = Color.cyan;
  	public Line(MultiVector L2) {
  		L = L2;
  	}
  	public Line(PointC point1, PointC point2) {
  		MultiVector point1MV = point1.getMultiVector();
  		MultiVector point2MV = point2.getMultiVector();
  		L = point1MV.OutProd(point2MV).OutProd(MultiVectors.n());
  	}
  	public void setColor(Color c) {
  		color = c;
  	}
  	public MultiVector getMoment() {
  		MultiVector m = L.OutProd(nbar).mult(N);
  		return m;
  	}
  	public MultiVector getLineVector() {
  		MultiVector lv = L.Rcontract(N);
  		return lv;
  	}
  	public MultiVector LinePoint(double alpha) {
  		// The returned result of this method is only the 3D Euclidean part of
  		// the
  		// full conformal point in MultiVector form!
  		MultiVector u = getLineVector();
  		MultiVector uinv = u.multSc(1.0 / (u.magnitude() * u.magnitude()));
  		MultiVector X = getMoment().mult(uinv).add(u.multSc(alpha));
  		return X;
  	}
  	public double[] linepoint3D(double alpha) {
  		double[] lps = new double[3];
  		lps[0] = LinePoint(alpha).get3DEuclidianPoint()[0];
  		lps[1] = LinePoint(alpha).get3DEuclidianPoint()[1];
  		lps[2] = LinePoint(alpha).get3DEuclidianPoint()[2];
  		return lps;
  	}
  	public void draw(Graphics g) {
  		//Line line = new Line(L);
  		double par = 5000.0 / getLineVector().magnitude();
  		Graphics2D g2 = (Graphics2D) g;
  		g2.setColor(color);
  		g2.setStroke(new BasicStroke(1.0f));
  		// Create a line using a general path object
  		GeneralPath p = new GeneralPath();
  		p.moveTo((float) linepoint3D(-par)[0], (float) linepoint3D(-par)[1]);
  		p.lineTo((float) linepoint3D(par)[0], (float) linepoint3D(par)[1]);
  		// render the line's path
  		g2.draw(p);
  	}
  	public void drawZ(Graphics g) {
  		//Line line = new Line(L);
  		double par = 5000.0 / getLineVector().magnitude();
 		Graphics2D g2 = (Graphics2D) g;
 		g2.setColor(color);
 		g2.setStroke(new BasicStroke(1.0f));
 		// Create a line using a general path object
 		GeneralPath p = new GeneralPath();
 		p.moveTo((float) linepoint3D(-par)[2], (float) linepoint3D(-par)[1]);
 		p.lineTo((float) linepoint3D(par)[2], (float) linepoint3D(par)[1]);
 		// render the line's path
 		g2.draw(p);
 	}
 //	public void setBasePoint(MultiVector basepoint, int p12) {
 //		if (p12 != 0 || p12 != 1)
 //			throw new IllegalArgumentException("index should be zero or one");
 //		basepoints[p12] = basepoint;
 //	}
 	
 	// This method is specific for remaking a circle when one of its
 	// basepoints is shifted!
 	//trying to make it immutable
 	//   public void remake(MultiVector movedBP, int bpno)
 	//     {
 	//      basepoints[bpno] = movedBP;
 	//      MultiVector Lnew = basepoints[0].OutProd(basepoints[1]).OutProd(n);
 	//      L = Lnew;
 	//     }
 //	public MultiVector PDistance(double[] picked) {
 //		MultiVector P, XP, u, uinv, distance;
 //		Line line = new Line(L);
 //		P = e1.multSc(picked[0]).add(e2.multSc(picked[1])).add(
 //				e3.multSc(picked[2]));
 //		XP = P.sub(line.LinePoint(0.0));
 //		u = line.getLineVector();
 //		uinv = u.multSc(1.0 / (u.magnitude() * u.magnitude()));
 //		distance = (XP.OutProd(u)).mult(uinv);
 //		return distance;
 //	}
 	public MultiVector PDistance2D(double[] point, MultiVector plane) {
 		// There should be a conformal way to determine the distance of a line
 		// and a point! Look for it.
 		// Euc3Vector class use eliminated on 2003-5-1!
 		MultiVector Lp, Pp, x, Tx, Txr, XPp, xpp, up, upinv, dp;
 		Lp = L.Lcontract(plane).mult(plane.multSc(-1.0));
 		Line linep = new Line(Lp);
 		PointC Pc = new PointC();
 		Pc.sete1(point[0]);
 		Pc.sete2(point[1]);
 		Pc.sete3(point[2]);
 		Pp = Pc.getMultiVector().Lcontract(plane).mult(plane.multSc(-1.0));
 		x = linep.LinePoint(0.0);
 		Tx = One.add(n.mult(x).multSc(0.5));
 		Txr = Tx.reverse();
 		XPp = Txr.mult(Pp).mult(Tx);
 		xpp = XPp.OutProd(N).mult(N); // 3D space part as MultiVector.
 		up = linep.getLineVector(); // Here the 2D vector as MultiVector, not
 		// conformal!
 		upinv = up.multSc(1.0 / (up.magnitude() * up.magnitude()));
 		dp = (xpp.OutProd(up)).mult(upinv);
 		return dp;
 	}
 	public double distanceXY(double[] point) {
 		MultiVector xyplane, dxy;
 		xyplane = e1.OutProd(e2).mult(N);
 		dxy = PDistance2D(point, xyplane);
 		return dxy.magnitude();
 	}
 	public double distanceYZ(double[] point) {
 		MultiVector yzplane, dyz;
 		yzplane = e2.OutProd(e3).mult(N);
 		dyz = PDistance2D(point, yzplane);
 		return dyz.magnitude();
 	}
 
 }