package java.awt.geom;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.NoSuchElementException;
public abstract class QuadCurve2D implements Shape, Cloneable
{
protected QuadCurve2D()
{
}
public abstract double getX1();
public abstract double getY1();
public abstract Point2D getP1();
public abstract double getCtrlX();
public abstract double getCtrlY();
public abstract Point2D getCtrlPt();
public abstract double getX2();
public abstract double getY2();
public abstract Point2D getP2();
public abstract void setCurve(double x1, double y1, double cx, double cy,
double x2, double y2);
public void setCurve(double[] coords, int offset)
{
setCurve(coords[offset++], coords[offset++],
coords[offset++], coords[offset++],
coords[offset++], coords[offset++]);
}
public void setCurve(Point2D p1, Point2D c, Point2D p2)
{
setCurve(p1.getX(), p1.getY(), c.getX(), c.getY(),
p2.getX(), p2.getY());
}
public void setCurve(Point2D[] pts, int offset)
{
setCurve(pts[offset].getX(), pts[offset++].getY(),
pts[offset].getX(), pts[offset++].getY(),
pts[offset].getX(), pts[offset++].getY());
}
public void setCurve(QuadCurve2D c)
{
setCurve(c.getX1(), c.getY1(), c.getCtrlX(), c.getCtrlY(),
c.getX2(), c.getY2());
}
public static double getFlatnessSq(double x1, double y1, double cx,
double cy, double x2, double y2)
{
throw new Error("not implemented");
}
public static double getFlatness(double x1, double y1, double cx, double cy,
double x2, double y2)
{
return Math.sqrt(getFlatnessSq(x1, y1, cx, cy, x2, y2));
}
public static double getFlatnessSq(double[] coords, int offset)
{
return getFlatnessSq(coords[offset++], coords[offset++],
coords[offset++], coords[offset++],
coords[offset++], coords[offset++]);
}
public static double getFlatness(double[] coords, int offset)
{
return Math.sqrt(getFlatnessSq(coords[offset++], coords[offset++],
coords[offset++], coords[offset++],
coords[offset++], coords[offset++]));
}
public double getFlatnessSq()
{
return getFlatnessSq(getX1(), getY1(), getCtrlX(), getCtrlY(),
getX2(), getY2());
}
public double getFlatness()
{
return Math.sqrt(getFlatnessSq(getX1(), getY1(), getCtrlX(), getCtrlY(),
getX2(), getY2()));
}
public void subdivide(QuadCurve2D l, QuadCurve2D r)
{
if (l == null)
l = new QuadCurve2D.Double();
if (r == null)
r = new QuadCurve2D.Double();
double[] d = new double[] { getX1(), getY1(), getCtrlX(), getCtrlY(),
getX2(), getY2(), 0, 0, 0, 0 };
subdivide(d, 0, d, 0, d, 4);
l.setCurve(d, 0);
r.setCurve(d, 4);
}
public static void subdivide(QuadCurve2D src, QuadCurve2D l, QuadCurve2D r)
{
src.subdivide(l, r);
}
public static void subdivide(double[] src, int srcOff,
double[] left, int leftOff,
double[] right, int rightOff)
{
throw new Error("not implemented");
}
public static int solveQuadratic(double[] eqn)
{
return solveQuadratic(eqn, eqn);
}
public static int solveQuadratic(double[] eqn, double[] res)
{
double c = eqn[0];
double b = eqn[1];
double a = eqn[2];
if (a == 0)
{
if (b == 0)
return -1;
res[0] = -c / b;
return 1;
}
c /= a;
b /= a * 2;
double det = Math.sqrt(b * b - c);
if (det != det)
return 0;
if (b > 0)
{
res[0] = -b - det;
res[1] = -c / (b + det);
}
else
{
res[0] = -c / (b - det);
res[1] = -b + det;
}
return 2;
}
public boolean contains(double x, double y)
{
throw new Error("not implemented");
}
public boolean contains(Point2D p)
{
return contains(p.getX(), p.getY());
}
public boolean intersects(double x, double y, double w, double h)
{
throw new Error("not implemented");
}
public boolean intersects(Rectangle2D r)
{
return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
public boolean contains(double x, double y, double w, double h)
{
throw new Error("not implemented");
}
public boolean contains(Rectangle2D r)
{
return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
public Rectangle getBounds()
{
return getBounds2D().getBounds();
}
public PathIterator getPathIterator(final AffineTransform at)
{
return new PathIterator()
{
private int current;
public int getWindingRule()
{
return WIND_NON_ZERO;
}
public boolean isDone()
{
return current < 2;
}
public void next()
{
current++;
}
public int currentSegment(float[] coords)
{
if (current == 0)
{
coords[0] = (float) getX1();
coords[1] = (float) getY1();
if (at != null)
at.transform(coords, 0, coords, 0, 1);
return SEG_MOVETO;
}
if (current == 1)
{
coords[0] = (float) getCtrlX();
coords[1] = (float) getCtrlY();
coords[2] = (float) getX2();
coords[3] = (float) getY2();
if (at != null)
at.transform(coords, 0, coords, 0, 2);
return SEG_QUADTO;
}
throw new NoSuchElementException("quad iterator out of bounds");
}
public int currentSegment(double[] coords)
{
if (current == 0)
{
coords[0] = getX1();
coords[1] = getY1();
if (at != null)
at.transform(coords, 0, coords, 0, 1);
return SEG_MOVETO;
}
if (current == 1)
{
coords[0] = getCtrlX();
coords[1] = getCtrlY();
coords[2] = getX2();
coords[3] = getY2();
if (at != null)
at.transform(coords, 0, coords, 0, 2);
return SEG_QUADTO;
}
throw new NoSuchElementException("quad iterator out of bounds");
}
};
}
public PathIterator getPathIterator(AffineTransform at, double flatness)
{
return new FlatteningPathIterator(getPathIterator(at), flatness);
}
public Object clone()
{
try
{
return super.clone();
}
catch (CloneNotSupportedException e)
{
throw (Error) new InternalError().initCause(e); }
}
public static class Double extends QuadCurve2D
{
public double x1;
public double y1;
public double ctrlx;
public double ctrly;
public double x2;
public double y2;
public Double()
{
}
public Double(double x1, double y1, double cx, double cy,
double x2, double y2)
{
this.x1 = x1;
this.y1 = y1;
ctrlx = cx;
ctrly = cy;
this.x2 = x2;
this.y2 = y2;
}
public double getX1()
{
return x1;
}
public double getY1()
{
return y1;
}
public Point2D getP1()
{
return new Point2D.Double(x1, y1);
}
public double getCtrlX()
{
return ctrlx;
}
public double getCtrlY()
{
return ctrly;
}
public Point2D getCtrlPt()
{
return new Point2D.Double(ctrlx, ctrly);
}
public double getX2()
{
return x2;
}
public double getY2()
{
return y2;
}
public Point2D getP2()
{
return new Point2D.Double(x2, y2);
}
public void setCurve(double x1, double y1, double cx, double cy,
double x2, double y2)
{
this.x1 = x1;
this.y1 = y1;
ctrlx = cx;
ctrly = cy;
this.x2 = x2;
this.y2 = y2;
}
public Rectangle2D getBounds2D()
{
double nx1 = Math.min(Math.min(x1, ctrlx), x2);
double ny1 = Math.min(Math.min(y1, ctrly), y2);
double nx2 = Math.max(Math.max(x1, ctrlx), x2);
double ny2 = Math.max(Math.max(y1, ctrly), y2);
return new Rectangle2D.Double(nx1, ny1, nx2 - nx1, ny2 - ny1);
}
}
public static class Float extends QuadCurve2D
{
public float x1;
public float y1;
public float ctrlx;
public float ctrly;
public float x2;
public float y2;
public Float()
{
}
public Float(float x1, float y1, float cx, float cy,
float x2, float y2)
{
this.x1 = x1;
this.y1 = y1;
ctrlx = cx;
ctrly = cy;
this.x2 = x2;
this.y2 = y2;
}
public double getX1()
{
return x1;
}
public double getY1()
{
return y1;
}
public Point2D getP1()
{
return new Point2D.Float(x1, y1);
}
public double getCtrlX()
{
return ctrlx;
}
public double getCtrlY()
{
return ctrly;
}
public Point2D getCtrlPt()
{
return new Point2D.Float(ctrlx, ctrly);
}
public double getX2()
{
return x2;
}
public double getY2()
{
return y2;
}
public Point2D getP2()
{
return new Point2D.Float(x2, y2);
}
public void setCurve(double x1, double y1, double cx, double cy,
double x2, double y2)
{
this.x1 = (float) x1;
this.y1 = (float) y1;
ctrlx = (float) cx;
ctrly = (float) cy;
this.x2 = (float) x2;
this.y2 = (float) y2;
}
public void setCurve(float x1, float y1, float cx, float cy,
float x2, float y2)
{
this.x1 = x1;
this.y1 = y1;
ctrlx = cx;
ctrly = cy;
this.x2 = x2;
this.y2 = y2;
}
public Rectangle2D getBounds2D()
{
float nx1 = (float) Math.min(Math.min(x1, ctrlx), x2);
float ny1 = (float) Math.min(Math.min(y1, ctrly), y2);
float nx2 = (float) Math.max(Math.max(x1, ctrlx), x2);
float ny2 = (float) Math.max(Math.max(y1, ctrly), y2);
return new Rectangle2D.Float(nx1, ny1, nx2 - nx1, ny2 - ny1);
}
} }