/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Denis M. Kishenko
* @version $Revision$
*/
package java.awt.geom;
import java.awt.Rectangle;
import java.awt.Shape;
import java.util.NoSuchElementException;
import org.apache.harmony.awt.gl.Crossing;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The Class CubicCurve2D is a Shape that represents a segment of a quadratic
* (Bezier) curve. The curved segment is determined by four points: a start
* point, an end point, and two control points. The control points give
* information about the tangent and next derivative at the endpoints according
* to the standard theory of Bezier curves. For more information on Bezier
* curves, see <a href="http://en.wikipedia.org/wiki/B%C3%A9zier_curve">this
* article</a>.
*
* @since Android 1.0
*/
public abstract class CubicCurve2D implements Shape, Cloneable {
/**
* The Class Float is the subclass of CubicCurve2D that has all of its data
* values stored with float-level precision.
*
* @since Android 1.0
*/
public static class Float extends CubicCurve2D {
/**
* The x coordinate of the starting point.
*/
public float x1;
/**
* The y coordinate of the starting point.
*/
public float y1;
/**
* The x coordinate of the first control point.
*/
public float ctrlx1;
/**
* The y coordinate of the first control point.
*/
public float ctrly1;
/**
* The x coordinate of the second control point.
*/
public float ctrlx2;
/**
* The y coordinate of the second control point.
*/
public float ctrly2;
/**
* The x coordinate of the end point.
*/
public float x2;
/**
* The y coordinate of the end point.
*/
public float y2;
/**
* Instantiates a new float-valued CubicCurve2D with all coordinate
* values set to zero.
*/
public Float() {
}
/**
* Instantiates a new float-valued CubicCurve2D with the specified
* coordinate values.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
*/
public Float(float x1, float y1, float ctrlx1, float ctrly1, float ctrlx2, float ctrly2,
float x2, float y2) {
setCurve(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
}
@Override
public double getX1() {
return x1;
}
@Override
public double getY1() {
return y1;
}
@Override
public double getCtrlX1() {
return ctrlx1;
}
@Override
public double getCtrlY1() {
return ctrly1;
}
@Override
public double getCtrlX2() {
return ctrlx2;
}
@Override
public double getCtrlY2() {
return ctrly2;
}
@Override
public double getX2() {
return x2;
}
@Override
public double getY2() {
return y2;
}
@Override
public Point2D getP1() {
return new Point2D.Float(x1, y1);
}
@Override
public Point2D getCtrlP1() {
return new Point2D.Float(ctrlx1, ctrly1);
}
@Override
public Point2D getCtrlP2() {
return new Point2D.Float(ctrlx2, ctrly2);
}
@Override
public Point2D getP2() {
return new Point2D.Float(x2, y2);
}
@Override
public void setCurve(double x1, double y1, double ctrlx1, double ctrly1, double ctrlx2,
double ctrly2, double x2, double y2) {
this.x1 = (float)x1;
this.y1 = (float)y1;
this.ctrlx1 = (float)ctrlx1;
this.ctrly1 = (float)ctrly1;
this.ctrlx2 = (float)ctrlx2;
this.ctrly2 = (float)ctrly2;
this.x2 = (float)x2;
this.y2 = (float)y2;
}
/**
* Sets the data values of the curve.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
*/
public void setCurve(float x1, float y1, float ctrlx1, float ctrly1, float ctrlx2,
float ctrly2, float x2, float y2) {
this.x1 = x1;
this.y1 = y1;
this.ctrlx1 = ctrlx1;
this.ctrly1 = ctrly1;
this.ctrlx2 = ctrlx2;
this.ctrly2 = ctrly2;
this.x2 = x2;
this.y2 = y2;
}
public Rectangle2D getBounds2D() {
float rx1 = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
float ry1 = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
float rx2 = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
float ry2 = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
return new Rectangle2D.Float(rx1, ry1, rx2 - rx1, ry2 - ry1);
}
}
/**
* The Class Double is the subclass of CubicCurve2D that has all of its data
* values stored with double-level precision.
*
* @since Android 1.0
*/
public static class Double extends CubicCurve2D {
/**
* The x coordinate of the starting point.
*/
public double x1;
/**
* The y coordinate of the starting point.
*/
public double y1;
/**
* The x coordinate of the first control point.
*/
public double ctrlx1;
/**
* The y coordinate of the first control point.
*/
public double ctrly1;
/**
* The x coordinate of the second control point.
*/
public double ctrlx2;
/**
* The y coordinate of the second control point.
*/
public double ctrly2;
/**
* The x coordinate of the end point.
*/
public double x2;
/**
* The y coordinate of the end point.
*/
public double y2;
/**
* Instantiates a new double-valued CubicCurve2D with all coordinate
* values set to zero.
*/
public Double() {
}
/**
* Instantiates a new double-valued CubicCurve2D with the specified
* coordinate values.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
*/
public Double(double x1, double y1, double ctrlx1, double ctrly1, double ctrlx2,
double ctrly2, double x2, double y2) {
setCurve(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2);
}
@Override
public double getX1() {
return x1;
}
@Override
public double getY1() {
return y1;
}
@Override
public double getCtrlX1() {
return ctrlx1;
}
@Override
public double getCtrlY1() {
return ctrly1;
}
@Override
public double getCtrlX2() {
return ctrlx2;
}
@Override
public double getCtrlY2() {
return ctrly2;
}
@Override
public double getX2() {
return x2;
}
@Override
public double getY2() {
return y2;
}
@Override
public Point2D getP1() {
return new Point2D.Double(x1, y1);
}
@Override
public Point2D getCtrlP1() {
return new Point2D.Double(ctrlx1, ctrly1);
}
@Override
public Point2D getCtrlP2() {
return new Point2D.Double(ctrlx2, ctrly2);
}
@Override
public Point2D getP2() {
return new Point2D.Double(x2, y2);
}
@Override
public void setCurve(double x1, double y1, double ctrlx1, double ctrly1, double ctrlx2,
double ctrly2, double x2, double y2) {
this.x1 = x1;
this.y1 = y1;
this.ctrlx1 = ctrlx1;
this.ctrly1 = ctrly1;
this.ctrlx2 = ctrlx2;
this.ctrly2 = ctrly2;
this.x2 = x2;
this.y2 = y2;
}
public Rectangle2D getBounds2D() {
double rx1 = Math.min(Math.min(x1, x2), Math.min(ctrlx1, ctrlx2));
double ry1 = Math.min(Math.min(y1, y2), Math.min(ctrly1, ctrly2));
double rx2 = Math.max(Math.max(x1, x2), Math.max(ctrlx1, ctrlx2));
double ry2 = Math.max(Math.max(y1, y2), Math.max(ctrly1, ctrly2));
return new Rectangle2D.Double(rx1, ry1, rx2 - rx1, ry2 - ry1);
}
}
/*
* CubicCurve2D path iterator
*/
/**
* The Iterator class for the Shape CubicCurve2D.
*/
class Iterator implements PathIterator {
/**
* The source CubicCurve2D object.
*/
CubicCurve2D c;
/**
* The path iterator transformation.
*/
AffineTransform t;
/**
* The current segment index.
*/
int index;
/**
* Constructs a new CubicCurve2D.Iterator for given line and
* transformation
*
* @param c
* the source CubicCurve2D object.
* @param t
* the affine transformation object.
*/
Iterator(CubicCurve2D c, AffineTransform t) {
this.c = c;
this.t = t;
}
public int getWindingRule() {
return WIND_NON_ZERO;
}
public boolean isDone() {
return index > 1;
}
public void next() {
index++;
}
public int currentSegment(double[] coords) {
if (isDone()) {
throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
}
int type;
int count;
if (index == 0) {
type = SEG_MOVETO;
coords[0] = c.getX1();
coords[1] = c.getY1();
count = 1;
} else {
type = SEG_CUBICTO;
coords[0] = c.getCtrlX1();
coords[1] = c.getCtrlY1();
coords[2] = c.getCtrlX2();
coords[3] = c.getCtrlY2();
coords[4] = c.getX2();
coords[5] = c.getY2();
count = 3;
}
if (t != null) {
t.transform(coords, 0, coords, 0, count);
}
return type;
}
public int currentSegment(float[] coords) {
if (isDone()) {
throw new NoSuchElementException(Messages.getString("awt.4B")); //$NON-NLS-1$
}
int type;
int count;
if (index == 0) {
type = SEG_MOVETO;
coords[0] = (float)c.getX1();
coords[1] = (float)c.getY1();
count = 1;
} else {
type = SEG_CUBICTO;
coords[0] = (float)c.getCtrlX1();
coords[1] = (float)c.getCtrlY1();
coords[2] = (float)c.getCtrlX2();
coords[3] = (float)c.getCtrlY2();
coords[4] = (float)c.getX2();
coords[5] = (float)c.getY2();
count = 3;
}
if (t != null) {
t.transform(coords, 0, coords, 0, count);
}
return type;
}
}
/**
* Instantiates a new 2-D cubic curve.
*/
protected CubicCurve2D() {
}
/**
* Gets the x coordinate of the starting point.
*
* @return the x coordinate of the starting point.
*/
public abstract double getX1();
/**
* Gets the y coordinate of the starting point.
*
* @return the y coordinate of the starting point.
*/
public abstract double getY1();
/**
* Gets the starting point.
*
* @return the starting point.
*/
public abstract Point2D getP1();
/**
* Gets the x coordinate of the first control point.
*
* @return the x coordinate of the first control point.
*/
public abstract double getCtrlX1();
/**
* Gets the y coordinate of the first control point.
*
* @return the y coordinate of the first control point.
*/
public abstract double getCtrlY1();
/**
* Gets the second control point.
*
* @return the second control point.
*/
public abstract Point2D getCtrlP1();
/**
* Gets the x coordinate of the second control point.
*
* @return the x coordinate of the second control point
*/
public abstract double getCtrlX2();
/**
* Gets the y coordinate of the second control point.
*
* @return the y coordinate of the second control point
*/
public abstract double getCtrlY2();
/**
* Gets the second control point.
*
* @return the second control point.
*/
public abstract Point2D getCtrlP2();
/**
* Gets the x coordinate of the end point.
*
* @return the x coordinate of the end point.
*/
public abstract double getX2();
/**
* Gets the y coordinate of the end point.
*
* @return the y coordinate of the end point.
*/
public abstract double getY2();
/**
* Gets the end point.
*
* @return the end point.
*/
public abstract Point2D getP2();
/**
* Sets the data of the curve.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
*/
public abstract void setCurve(double x1, double y1, double ctrlx1, double ctrly1,
double ctrlx2, double ctrly2, double x2, double y2);
/**
* Sets the data of the curve as point objects.
*
* @param p1
* the starting point.
* @param cp1
* the first control point.
* @param cp2
* the second control point.
* @param p2
* the end point.
* @throws NullPointerException
* if any of the points is null.
*/
public void setCurve(Point2D p1, Point2D cp1, Point2D cp2, Point2D p2) {
setCurve(p1.getX(), p1.getY(), cp1.getX(), cp1.getY(), cp2.getX(), cp2.getY(), p2.getX(),
p2.getY());
}
/**
* Sets the data of the curve by reading the data from an array of values.
* The values are read in the same order as the arguments of the method
* {@link CubicCurve2D#setCurve(double, double, double, double, double, double, double, double)}
* .
*
* @param coords
* the array of values containing the new coordinates.
* @param offset
* the offset of the data to read within the array.
* @throws ArrayIndexOutOfBoundsException
* if {@code coords.length} < offset + 8.
* @throws NullPointerException
* if the coordinate array is null.
*/
public void setCurve(double[] coords, int offset) {
setCurve(coords[offset + 0], coords[offset + 1], coords[offset + 2], coords[offset + 3],
coords[offset + 4], coords[offset + 5], coords[offset + 6], coords[offset + 7]);
}
/**
* Sets the data of the curve by reading the data from an array of points.
* The values are read in the same order as the arguments of the method
* {@link CubicCurve2D#setCurve(Point2D, Point2D, Point2D, Point2D)}
*
* @param points
* the array of points containing the new coordinates.
* @param offset
* the offset of the data to read within the array.
* @throws ArrayIndexOutOfBoundsException
* if {@code points.length} < offset + .
* @throws NullPointerException
* if the point array is null.
*/
public void setCurve(Point2D[] points, int offset) {
setCurve(points[offset + 0].getX(), points[offset + 0].getY(), points[offset + 1].getX(),
points[offset + 1].getY(), points[offset + 2].getX(), points[offset + 2].getY(),
points[offset + 3].getX(), points[offset + 3].getY());
}
/**
* Sets the data of the curve by copying it from another CubicCurve2D.
*
* @param curve
* the curve to copy the data points from.
* @throws NullPointerException
* if the curve is null.
*/
public void setCurve(CubicCurve2D curve) {
setCurve(curve.getX1(), curve.getY1(), curve.getCtrlX1(), curve.getCtrlY1(), curve
.getCtrlX2(), curve.getCtrlY2(), curve.getX2(), curve.getY2());
}
/**
* Gets the square of the flatness of this curve, where the flatness is the
* maximum distance from the curves control points to the line segment
* connecting the two points.
*
* @return the square of the flatness.
*/
public double getFlatnessSq() {
return getFlatnessSq(getX1(), getY1(), getCtrlX1(), getCtrlY1(), getCtrlX2(), getCtrlY2(),
getX2(), getY2());
}
/**
* Gets the square of the flatness of the cubic curve segment defined by the
* specified values.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
* @return the square of the flatness.
*/
public static double getFlatnessSq(double x1, double y1, double ctrlx1, double ctrly1,
double ctrlx2, double ctrly2, double x2, double y2) {
return Math.max(Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx1, ctrly1), Line2D.ptSegDistSq(x1,
y1, x2, y2, ctrlx2, ctrly2));
}
/**
* Gets the square of the flatness of the cubic curve segment defined by the
* specified values. The values are read in the same order as the arguments
* of the method
* {@link CubicCurve2D#getFlatnessSq(double, double, double, double, double, double, double, double)}
* .
*
* @param coords
* the array of points containing the new coordinates.
* @param offset
* the offset of the data to read within the array.
* @return the square of the flatness.
* @throws ArrayIndexOutOfBoundsException
* if points.length < offset + .
* @throws NullPointerException
* if the point array is null.
*/
public static double getFlatnessSq(double coords[], int offset) {
return getFlatnessSq(coords[offset + 0], coords[offset + 1], coords[offset + 2],
coords[offset + 3], coords[offset + 4], coords[offset + 5], coords[offset + 6],
coords[offset + 7]);
}
/**
* Gets the flatness of this curve, where the flatness is the maximum
* distance from the curves control points to the line segment connecting
* the two points.
*
* @return the flatness of this curve.
*/
public double getFlatness() {
return getFlatness(getX1(), getY1(), getCtrlX1(), getCtrlY1(), getCtrlX2(), getCtrlY2(),
getX2(), getY2());
}
/**
* Gets the flatness of the cubic curve segment defined by the specified
* values.
*
* @param x1
* the x coordinate of the starting point.
* @param y1
* the y coordinate of the starting point.
* @param ctrlx1
* the x coordinate of the first control point.
* @param ctrly1
* the y coordinate of the first control point.
* @param ctrlx2
* the x coordinate of the second control point.
* @param ctrly2
* the y coordinate of the second control point.
* @param x2
* the x coordinate of the end point.
* @param y2
* the y coordinate of the end point.
* @return the flatness.
*/
public static double getFlatness(double x1, double y1, double ctrlx1, double ctrly1,
double ctrlx2, double ctrly2, double x2, double y2) {
return Math.sqrt(getFlatnessSq(x1, y1, ctrlx1, ctrly1, ctrlx2, ctrly2, x2, y2));
}
/**
* Gets the flatness of the cubic curve segment defined by the specified
* values. The values are read in the same order as the arguments of the
* method
* {@link CubicCurve2D#getFlatness(double, double, double, double, double, double, double, double)}
* .
*
* @param coords
* the array of points containing the new coordinates.
* @param offset
* the offset of the data to read within the array.
* @return the flatness.
* @throws ArrayIndexOutOfBoundsException
* if points.length < offset + .
* @throws NullPointerException
* if the point array is null.
*/
public static double getFlatness(double coords[], int offset) {
return getFlatness(coords[offset + 0], coords[offset + 1], coords[offset + 2],
coords[offset + 3], coords[offset + 4], coords[offset + 5], coords[offset + 6],
coords[offset + 7]);
}
/**
* Creates the data for two cubic curves by dividing this curve in two. The
* division point is the point on the curve that is closest to the average
* of curve's two control points. The two new control points (nearest the
* new endpoint) are computed by averaging the original control points with
* the new endpoint. The data of this curve is left unchanged.
*
* @param left
* the CubicCurve2D where the left (start) segment's data is
* written.
* @param right
* the CubicCurve2D where the right (end) segment's data is
* written.
* @throws NullPointerException
* if either curve is null.
*/
public void subdivide(CubicCurve2D left, CubicCurve2D right) {
subdivide(this, left, right);
}
/**
* Creates the data for two cubic curves by dividing the specified curve in
* two. The division point is the point on the curve that is closest to the
* average of curve's two control points. The two new control points
* (nearest the new endpoint) are computed by averaging the original control
* points with the new endpoint. The data of the source curve is left
* unchanged.
*
* @param src
* the original curve to be divided in two.
* @param left
* the CubicCurve2D where the left (start) segment's data is
* written.
* @param right
* the CubicCurve2D where the right (end) segment's data is
* written.
* @throws NullPointerException
* if either curve is null.
*/
public static void subdivide(CubicCurve2D src, CubicCurve2D left, CubicCurve2D right) {
double x1 = src.getX1();
double y1 = src.getY1();
double cx1 = src.getCtrlX1();
double cy1 = src.getCtrlY1();
double cx2 = src.getCtrlX2();
double cy2 = src.getCtrlY2();
double x2 = src.getX2();
double y2 = src.getY2();
double cx = (cx1 + cx2) / 2.0;
double cy = (cy1 + cy2) / 2.0;
cx1 = (x1 + cx1) / 2.0;
cy1 = (y1 + cy1) / 2.0;
cx2 = (x2 + cx2) / 2.0;
cy2 = (y2 + cy2) / 2.0;
double ax = (cx1 + cx) / 2.0;
double ay = (cy1 + cy) / 2.0;
double bx = (cx2 + cx) / 2.0;
double by = (cy2 + cy) / 2.0;
cx = (ax + bx) / 2.0;
cy = (ay + by) / 2.0;
if (left != null) {
left.setCurve(x1, y1, cx1, cy1, ax, ay, cx, cy);
}
if (right != null) {
right.setCurve(cx, cy, bx, by, cx2, cy2, x2, y2);
}
}
/**
* Creates the data for two cubic curves by dividing the specified curve in
* two. The division point is the point on the curve that is closest to the
* average of curve's two control points. The two new control points
* (nearest the new endpoint) are computed by averaging the original control
* points with the new endpoint. The data of the source curve is left
* unchanged. The data for the three curves is read/written in the usual
* order: { x1, y1, ctrlx1, ctrly1, ctrlx2, crtry2, x2, y3 }
*
* @param src
* the array that gives the data values for the source curve.
* @param srcOff
* the offset in the src array to read the values from.
* @param left
* the array where the coordinates of the start curve should be
* written.
* @param leftOff
* the offset in the left array to start writing the values.
* @param right
* the array where the coordinates of the end curve should be
* written.
* @param rightOff
* the offset in the right array to start writing the values.
* @throws ArrayIndexOutOfBoundsException
* if src.length < srcoff + 8 or if left.length < leftOff + 8 or
* if right.length < rightOff + 8.
* @throws NullPointerException
* if one of the arrays is null.
*/
public static void subdivide(double src[], int srcOff, double left[], int leftOff,
double right[], int rightOff) {
double x1 = src[srcOff + 0];
double y1 = src[srcOff + 1];
double cx1 = src[srcOff + 2];
double cy1 = src[srcOff + 3];
double cx2 = src[srcOff + 4];
double cy2 = src[srcOff + 5];
double x2 = src[srcOff + 6];
double y2 = src[srcOff + 7];
double cx = (cx1 + cx2) / 2.0;
double cy = (cy1 + cy2) / 2.0;
cx1 = (x1 + cx1) / 2.0;
cy1 = (y1 + cy1) / 2.0;
cx2 = (x2 + cx2) / 2.0;
cy2 = (y2 + cy2) / 2.0;
double ax = (cx1 + cx) / 2.0;
double ay = (cy1 + cy) / 2.0;
double bx = (cx2 + cx) / 2.0;
double by = (cy2 + cy) / 2.0;
cx = (ax + bx) / 2.0;
cy = (ay + by) / 2.0;
if (left != null) {
left[leftOff + 0] = x1;
left[leftOff + 1] = y1;
left[leftOff + 2] = cx1;
left[leftOff + 3] = cy1;
left[leftOff + 4] = ax;
left[leftOff + 5] = ay;
left[leftOff + 6] = cx;
left[leftOff + 7] = cy;
}
if (right != null) {
right[rightOff + 0] = cx;
right[rightOff + 1] = cy;
right[rightOff + 2] = bx;
right[rightOff + 3] = by;
right[rightOff + 4] = cx2;
right[rightOff + 5] = cy2;
right[rightOff + 6] = x2;
right[rightOff + 7] = y2;
}
}
/**
* Finds the roots of the cubic polynomial. This is accomplished by finding
* the (real) values of x that solve the following equation: eqn[3]*x*x*x +
* eqn[2]*x*x + eqn[1]*x + eqn[0] = 0. The solutions are written back into
* the array eqn starting from the index 0 in the array. The return value
* tells how many array elements have been changed by this method call.
*
* @param eqn
* an array containing the coefficients of the cubic polynomial
* to solve.
* @return the number of roots of the cubic polynomial.
* @throws ArrayIndexOutOfBoundsException
* if eqn.length < 4.
* @throws NullPointerException
* if the array is null.
*/
public static int solveCubic(double eqn[]) {
return solveCubic(eqn, eqn);
}
/**
* Finds the roots of the cubic polynomial. This is accomplished by finding
* the (real) values of x that solve the following equation: eqn[3]*x*x*x +
* eqn[2]*x*x + eqn[1]*x + eqn[0] = 0. The solutions are written into the
* array res starting from the index 0 in the array. The return value tells
* how many array elements have been changed by this method call.
*
* @param eqn
* an array containing the coefficients of the cubic polynomial
* to solve.
* @param res
* the array that this method writes the results into.
* @return the number of roots of the cubic polynomial.
* @throws ArrayIndexOutOfBoundsException
* if eqn.length < 4 or if res.length is less than the number of
* roots.
* @throws NullPointerException
* if either array is null.
*/
public static int solveCubic(double eqn[], double res[]) {
return Crossing.solveCubic(eqn, res);
}
public boolean contains(double px, double py) {
return Crossing.isInsideEvenOdd(Crossing.crossShape(this, px, py));
}
public boolean contains(double rx, double ry, double rw, double rh) {
int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
return cross != Crossing.CROSSING && Crossing.isInsideEvenOdd(cross);
}
public boolean intersects(double rx, double ry, double rw, double rh) {
int cross = Crossing.intersectShape(this, rx, ry, rw, rh);
return cross == Crossing.CROSSING || Crossing.isInsideEvenOdd(cross);
}
public boolean contains(Point2D p) {
return contains(p.getX(), p.getY());
}
public boolean intersects(Rectangle2D r) {
return intersects(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
public boolean contains(Rectangle2D r) {
return contains(r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
public Rectangle getBounds() {
return getBounds2D().getBounds();
}
public PathIterator getPathIterator(AffineTransform t) {
return new Iterator(this, t);
}
public PathIterator getPathIterator(AffineTransform at, double flatness) {
return new FlatteningPathIterator(getPathIterator(at), flatness);
}
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
} |
