1351 lines
53 KiB
Java
1351 lines
53 KiB
Java
/*
|
|
* Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code 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 General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 4172661
|
|
* @summary Tests all public methods of Path2D classes on all 3 variants
|
|
* Path2D.Float, Path2D.Double, and GeneralPath.
|
|
* REMIND: Note that the hit testing tests will fail
|
|
* occasionally due to precision bugs in the various hit
|
|
* testing methods in the geometry classes.
|
|
* (Failure rates vary from 1 per 100 runs to 1 per thousands).
|
|
* See bug 6396047 to track progress on these failures.
|
|
*/
|
|
|
|
import java.awt.Rectangle;
|
|
import java.awt.Shape;
|
|
import java.awt.geom.AffineTransform;
|
|
import java.awt.geom.Arc2D;
|
|
import java.awt.geom.Area;
|
|
import java.awt.geom.CubicCurve2D;
|
|
import java.awt.geom.Ellipse2D;
|
|
import java.awt.geom.FlatteningPathIterator;
|
|
import java.awt.geom.GeneralPath;
|
|
import java.awt.geom.Line2D;
|
|
import java.awt.geom.Path2D;
|
|
import java.awt.geom.PathIterator;
|
|
import java.awt.geom.Point2D;
|
|
import java.awt.geom.QuadCurve2D;
|
|
import java.awt.geom.Rectangle2D;
|
|
import java.awt.geom.RoundRectangle2D;
|
|
import java.util.NoSuchElementException;
|
|
|
|
public class UnitTest {
|
|
public static boolean verbose;
|
|
|
|
public static final int WIND_NON_ZERO = PathIterator.WIND_NON_ZERO;
|
|
public static final int WIND_EVEN_ODD = PathIterator.WIND_EVEN_ODD;
|
|
|
|
public static int CoordsForType[] = { 2, 2, 4, 6, 0 };
|
|
|
|
public static AffineTransform TxIdentity = new AffineTransform();
|
|
public static AffineTransform TxComplex = makeAT();
|
|
|
|
public static Shape TestShapes[];
|
|
public static SampleShape ShortSampleNonZero;
|
|
public static SampleShape ShortSampleEvenOdd;
|
|
public static SampleShape LongSampleNonZero;
|
|
public static SampleShape LongSampleEvenOdd;
|
|
|
|
public static Shape EmptyShapeNonZero =
|
|
new EmptyShape(WIND_NON_ZERO);
|
|
public static Shape EmptyShapeEvenOdd =
|
|
new EmptyShape(WIND_EVEN_ODD);
|
|
|
|
// Note: We pick a shape that is not anywhere near any of
|
|
// our test shapes so that the Path2D does not try to collapse
|
|
// out the connecting segment - an optimization that is too
|
|
// difficult to account for in the AppendedShape code.
|
|
public static Shape AppendShape = new Arc2D.Double(1000, 1000, 40, 40,
|
|
Math.PI/4, Math.PI,
|
|
Arc2D.CHORD);
|
|
|
|
public static AffineTransform makeAT() {
|
|
AffineTransform at = new AffineTransform();
|
|
at.scale(0.66, 0.23);
|
|
at.rotate(Math.toRadians(35.0));
|
|
at.shear(0.78, 1.32);
|
|
return at;
|
|
}
|
|
|
|
public static void init() {
|
|
TestShapes = new Shape[] {
|
|
EmptyShapeNonZero,
|
|
EmptyShapeEvenOdd,
|
|
new Line2D.Double(),
|
|
new Line2D.Double(rpc(), rpc(), rpc(), rpc()),
|
|
new Line2D.Double(rnc(), rnc(), rnc(), rnc()),
|
|
new Rectangle2D.Double(),
|
|
new Rectangle2D.Double(rpc(), rpc(), -1, -1),
|
|
new Rectangle2D.Double(rpc(), rpc(), rd(), rd()),
|
|
new Rectangle2D.Double(rnc(), rnc(), rd(), rd()),
|
|
new Ellipse2D.Double(),
|
|
new Ellipse2D.Double(rpc(), rpc(), -1, -1),
|
|
new Ellipse2D.Double(rpc(), rpc(), rd(), rd()),
|
|
new Ellipse2D.Double(rnc(), rnc(), rd(), rd()),
|
|
new Arc2D.Double(Arc2D.OPEN),
|
|
new Arc2D.Double(Arc2D.CHORD),
|
|
new Arc2D.Double(Arc2D.PIE),
|
|
new Arc2D.Double(rpc(), rpc(), -1, -1, rt(), rt(), Arc2D.OPEN),
|
|
new Arc2D.Double(rpc(), rpc(), -1, -1, rt(), rt(), Arc2D.CHORD),
|
|
new Arc2D.Double(rpc(), rpc(), -1, -1, rt(), rt(), Arc2D.PIE),
|
|
new Arc2D.Double(rpc(), rpc(), rd(), rd(), rt(), rt(), Arc2D.OPEN),
|
|
new Arc2D.Double(rpc(), rpc(), rd(), rd(), rt(), rt(), Arc2D.CHORD),
|
|
new Arc2D.Double(rpc(), rpc(), rd(), rd(), rt(), rt(), Arc2D.PIE),
|
|
new Arc2D.Double(rnc(), rnc(), rd(), rd(), rt(), rt(), Arc2D.OPEN),
|
|
new Arc2D.Double(rnc(), rnc(), rd(), rd(), rt(), rt(), Arc2D.CHORD),
|
|
new Arc2D.Double(rnc(), rnc(), rd(), rd(), rt(), rt(), Arc2D.PIE),
|
|
new RoundRectangle2D.Double(),
|
|
new RoundRectangle2D.Double(rpc(), rpc(), -1, -1, ra(), ra()),
|
|
new RoundRectangle2D.Double(rpc(), rpc(), rd(), rd(), ra(), ra()),
|
|
new RoundRectangle2D.Double(rnc(), rnc(), rd(), rd(), ra(), ra()),
|
|
new QuadCurve2D.Double(),
|
|
new QuadCurve2D.Double(rpc(), rpc(), rpc(), rpc(), rpc(), rpc()),
|
|
new QuadCurve2D.Double(rnc(), rnc(), rnc(), rnc(), rnc(), rnc()),
|
|
new CubicCurve2D.Double(),
|
|
new CubicCurve2D.Double(rpc(), rpc(), rpc(), rpc(),
|
|
rpc(), rpc(), rpc(), rpc()),
|
|
new CubicCurve2D.Double(rnc(), rnc(), rnc(), rnc(),
|
|
rnc(), rnc(), rnc(), rnc()),
|
|
makeGeneralPath(WIND_NON_ZERO, 1.0),
|
|
makeGeneralPath(WIND_EVEN_ODD, 1.0),
|
|
makeGeneralPath(WIND_NON_ZERO, -1.0),
|
|
makeGeneralPath(WIND_EVEN_ODD, -1.0),
|
|
};
|
|
|
|
int types[] = new int[100];
|
|
int i = 0;
|
|
types[i++] = PathIterator.SEG_MOVETO;
|
|
types[i++] = PathIterator.SEG_LINETO;
|
|
types[i++] = PathIterator.SEG_QUADTO;
|
|
types[i++] = PathIterator.SEG_CUBICTO;
|
|
types[i++] = PathIterator.SEG_CLOSE;
|
|
int shortlen = i;
|
|
int prevt = types[i-1];
|
|
while (i < types.length) {
|
|
int t;
|
|
do {
|
|
t = (int) (Math.random() * 5);
|
|
} while (t == prevt &&
|
|
(t == PathIterator.SEG_MOVETO ||
|
|
t == PathIterator.SEG_CLOSE));
|
|
types[i++] = t;
|
|
prevt = t;
|
|
}
|
|
|
|
int numcoords = 0;
|
|
int numshortcoords = 0;
|
|
for (i = 0; i < types.length; i++) {
|
|
if (i == shortlen) {
|
|
numshortcoords = numcoords;
|
|
}
|
|
numcoords += CoordsForType[types[i]];
|
|
}
|
|
double coords[] = new double[numcoords];
|
|
for (i = 0; i < coords.length; i++) {
|
|
coords[i] = rpc();
|
|
}
|
|
ShortSampleNonZero = new SampleShape(WIND_NON_ZERO,
|
|
types, coords,
|
|
shortlen, numshortcoords);
|
|
ShortSampleEvenOdd = new SampleShape(WIND_EVEN_ODD,
|
|
types, coords,
|
|
shortlen, numshortcoords);
|
|
LongSampleNonZero = new SampleShape(WIND_NON_ZERO,
|
|
types, coords,
|
|
types.length, numcoords);
|
|
LongSampleEvenOdd = new SampleShape(WIND_EVEN_ODD,
|
|
types, coords,
|
|
types.length, numcoords);
|
|
}
|
|
|
|
public static GeneralPath makeGeneralPath(int windingrule, double sign) {
|
|
GeneralPath gp = new GeneralPath(windingrule);
|
|
gp.moveTo((float) (sign * rpc()), (float) (sign * rpc()));
|
|
gp.lineTo((float) (sign * rpc()), (float) (sign * rpc()));
|
|
gp.quadTo((float) (sign * rpc()), (float) (sign * rpc()),
|
|
(float) (sign * rpc()), (float) (sign * rpc()));
|
|
gp.curveTo((float) (sign * rpc()), (float) (sign * rpc()),
|
|
(float) (sign * rpc()), (float) (sign * rpc()),
|
|
(float) (sign * rpc()), (float) (sign * rpc()));
|
|
gp.closePath();
|
|
return gp;
|
|
}
|
|
|
|
// Due to odd issues with the sizes of errors when the values
|
|
// being manipulated are near zero, we try to avoid values
|
|
// near zero by ensuring that both the rpc (positive coords)
|
|
// stay away from zero and also by ensuring that the rpc+rd
|
|
// (positive coords + dimensions) stay away from zero. We
|
|
// also ensure that rnc+rd (negative coords + dimension) stay
|
|
// suitably negative without approaching zero.
|
|
|
|
// Random positive coordinate (10 -> 110)
|
|
// rpc + rd gives a total range of (30 -> 170)
|
|
public static double rpc() {
|
|
return (Math.random() * 100.0) + 10.0;
|
|
}
|
|
|
|
// Random negative coordinate (-200 -> -100)
|
|
// rnc + rd gives a total range of (-180 -> -40)
|
|
public static double rnc() {
|
|
return (Math.random() * 100.0) - 200.0;
|
|
}
|
|
|
|
// Random dimension (20 -> 60)
|
|
public static double rd() {
|
|
return (Math.random() * 40.0) + 20.0;
|
|
}
|
|
|
|
// Random arc width/height (0.1 -> 5.1)
|
|
public static double ra() {
|
|
return (Math.random() * 5.0) + 0.1;
|
|
}
|
|
|
|
// Random arc angle (theta) (PI/4 => 5PI/4)
|
|
public static double rt() {
|
|
return (Math.random() * Math.PI) + Math.PI/4;
|
|
}
|
|
|
|
public static int fltulpdiff(double v1, double v2) {
|
|
if (v1 == v2) {
|
|
return 0;
|
|
}
|
|
float vf1 = (float) v1;
|
|
float vf2 = (float) v2;
|
|
if (vf1 == vf2) {
|
|
return 0;
|
|
}
|
|
float diff = Math.abs(vf1-vf2);
|
|
//float ulp = Math.ulp((float) ((vf1 + vf2)/2f));
|
|
float ulp = Math.max(Math.ulp(vf1), Math.ulp(vf2));
|
|
if (verbose && diff > ulp) {
|
|
System.out.println("v1 = "+vf1+", ulp = "+Math.ulp(vf1));
|
|
System.out.println("v2 = "+vf2+", ulp = "+Math.ulp(vf2));
|
|
System.out.println((diff/ulp)+" ulps");
|
|
}
|
|
return (int) (diff/ulp);
|
|
}
|
|
|
|
public static int fltulpless(double v1, double v2) {
|
|
if (v1 >= v2) {
|
|
return 0;
|
|
}
|
|
float vf1 = (float) v1;
|
|
float vf2 = (float) v2;
|
|
if (vf1 >= vf2) {
|
|
return 0;
|
|
}
|
|
float diff = Math.abs(vf1-vf2);
|
|
//float ulp = Math.ulp((float) ((vf1 + vf2)/2f));
|
|
float ulp = Math.max(Math.ulp(vf1), Math.ulp(vf2));
|
|
if (verbose && diff > ulp) {
|
|
System.out.println("v1 = "+vf1+", ulp = "+Math.ulp(vf1));
|
|
System.out.println("v2 = "+vf2+", ulp = "+Math.ulp(vf2));
|
|
System.out.println((diff/ulp)+" ulps");
|
|
}
|
|
return (int) (diff/ulp);
|
|
}
|
|
|
|
public static int dblulpdiff(double v1, double v2) {
|
|
if (v1 == v2) {
|
|
return 0;
|
|
}
|
|
double diff = Math.abs(v1-v2);
|
|
//double ulp = Math.ulp((v1 + v2)/2.0);
|
|
double ulp = Math.max(Math.ulp(v1), Math.ulp(v2));
|
|
if (verbose && diff > ulp) {
|
|
System.out.println("v1 = "+v1+", ulp = "+Math.ulp(v1));
|
|
System.out.println("v2 = "+v2+", ulp = "+Math.ulp(v2));
|
|
System.out.println((diff/ulp)+" ulps");
|
|
}
|
|
return (int) (diff/ulp);
|
|
}
|
|
|
|
public static abstract class Creator {
|
|
public abstract Path2D makePath();
|
|
public abstract Path2D makePath(int windingrule);
|
|
public abstract Path2D makePath(int windingrule, int capacity);
|
|
public abstract Path2D makePath(Shape s);
|
|
public abstract Path2D makePath(Shape s, AffineTransform at);
|
|
|
|
public abstract boolean supportsFloatCompose();
|
|
public abstract int getRecommendedTxMaxUlp();
|
|
|
|
public abstract void compare(PathIterator testpi,
|
|
PathIterator refpi,
|
|
AffineTransform at,
|
|
int maxulp);
|
|
}
|
|
|
|
public static class FltCreator extends Creator {
|
|
public Path2D makePath() {
|
|
return new Path2D.Float();
|
|
}
|
|
public Path2D makePath(int windingrule) {
|
|
return new Path2D.Float(windingrule);
|
|
}
|
|
public Path2D makePath(int windingrule, int capacity) {
|
|
return new Path2D.Float(windingrule, capacity);
|
|
}
|
|
public Path2D makePath(Shape s) {
|
|
return new Path2D.Float(s);
|
|
}
|
|
public Path2D makePath(Shape s, AffineTransform at) {
|
|
return new Path2D.Float(s, at);
|
|
}
|
|
|
|
public boolean supportsFloatCompose() {
|
|
return true;
|
|
}
|
|
public int getRecommendedTxMaxUlp() {
|
|
return 5;
|
|
}
|
|
|
|
public void compare(PathIterator testpi,
|
|
PathIterator refpi,
|
|
AffineTransform at,
|
|
int maxulp)
|
|
{
|
|
if (testpi.getWindingRule() != refpi.getWindingRule()) {
|
|
throw new RuntimeException("wrong winding rule");
|
|
}
|
|
float testcoords[] = new float[6];
|
|
float refcoords[] = new float[6];
|
|
while (!testpi.isDone()) {
|
|
if (refpi.isDone()) {
|
|
throw new RuntimeException("too many segments");
|
|
}
|
|
int testtype = testpi.currentSegment(testcoords);
|
|
int reftype = refpi.currentSegment(refcoords);
|
|
if (testtype != reftype) {
|
|
throw new RuntimeException("different segment types");
|
|
}
|
|
if (at != null) {
|
|
at.transform(refcoords, 0, refcoords, 0,
|
|
CoordsForType[reftype]/2);
|
|
}
|
|
for (int i = 0; i < CoordsForType[testtype]; i++) {
|
|
int ulps = fltulpdiff(testcoords[i], refcoords[i]);
|
|
if (ulps > maxulp) {
|
|
throw new RuntimeException("coords are different: "+
|
|
testcoords[i]+" != "+
|
|
refcoords[i]+
|
|
" ("+ulps+" ulps)");
|
|
}
|
|
}
|
|
testpi.next();
|
|
refpi.next();
|
|
}
|
|
if (!refpi.isDone()) {
|
|
throw new RuntimeException("not enough segments");
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class DblCreator extends Creator {
|
|
public Path2D makePath() {
|
|
return new Path2D.Double();
|
|
}
|
|
public Path2D makePath(int windingrule) {
|
|
return new Path2D.Double(windingrule);
|
|
}
|
|
public Path2D makePath(int windingrule, int capacity) {
|
|
return new Path2D.Double(windingrule, capacity);
|
|
}
|
|
public Path2D makePath(Shape s) {
|
|
return new Path2D.Double(s);
|
|
}
|
|
public Path2D makePath(Shape s, AffineTransform at) {
|
|
return new Path2D.Double(s, at);
|
|
}
|
|
|
|
public boolean supportsFloatCompose() {
|
|
return false;
|
|
}
|
|
public int getRecommendedTxMaxUlp() {
|
|
return 3;
|
|
}
|
|
|
|
public void compare(PathIterator testpi,
|
|
PathIterator refpi,
|
|
AffineTransform at,
|
|
int maxulp)
|
|
{
|
|
if (testpi.getWindingRule() != refpi.getWindingRule()) {
|
|
throw new RuntimeException("wrong winding rule");
|
|
}
|
|
double testcoords[] = new double[6];
|
|
double refcoords[] = new double[6];
|
|
while (!testpi.isDone()) {
|
|
if (refpi.isDone()) {
|
|
throw new RuntimeException("too many segments");
|
|
}
|
|
int testtype = testpi.currentSegment(testcoords);
|
|
int reftype = refpi.currentSegment(refcoords);
|
|
if (testtype != reftype) {
|
|
throw new RuntimeException("different segment types");
|
|
}
|
|
if (at != null) {
|
|
at.transform(refcoords, 0, refcoords, 0,
|
|
CoordsForType[reftype]/2);
|
|
}
|
|
for (int i = 0; i < CoordsForType[testtype]; i++) {
|
|
int ulps = dblulpdiff(testcoords[i], refcoords[i]);
|
|
if (ulps > maxulp) {
|
|
throw new RuntimeException("coords are different: "+
|
|
testcoords[i]+" != "+
|
|
refcoords[i]+
|
|
" ("+ulps+" ulps)");
|
|
}
|
|
}
|
|
testpi.next();
|
|
refpi.next();
|
|
}
|
|
if (!refpi.isDone()) {
|
|
throw new RuntimeException("not enough segments");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public static class GPCreator extends FltCreator {
|
|
public Path2D makePath() {
|
|
return new GeneralPath();
|
|
}
|
|
public Path2D makePath(int windingrule) {
|
|
return new GeneralPath(windingrule);
|
|
}
|
|
public Path2D makePath(int windingrule, int capacity) {
|
|
return new GeneralPath(windingrule, capacity);
|
|
}
|
|
public Path2D makePath(Shape s) {
|
|
return new GeneralPath(s);
|
|
}
|
|
public Path2D makePath(Shape s, AffineTransform at) {
|
|
GeneralPath gp = new GeneralPath();
|
|
PathIterator pi = s.getPathIterator(at);
|
|
gp.setWindingRule(pi.getWindingRule());
|
|
gp.append(pi, false);
|
|
return gp;
|
|
}
|
|
|
|
public boolean supportsFloatCompose() {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static class EmptyShape implements Shape {
|
|
private int windingrule;
|
|
|
|
public EmptyShape(int windingrule) {
|
|
this.windingrule = windingrule;
|
|
}
|
|
|
|
public Rectangle getBounds() {
|
|
return new Rectangle();
|
|
}
|
|
public Rectangle2D getBounds2D() {
|
|
return new Rectangle();
|
|
}
|
|
public boolean contains(double x, double y) {
|
|
return false;
|
|
}
|
|
public boolean contains(Point2D p) {
|
|
return false;
|
|
}
|
|
public boolean intersects(double x, double y, double w, double h) {
|
|
return false;
|
|
}
|
|
public boolean intersects(Rectangle2D r) {
|
|
return false;
|
|
}
|
|
public boolean contains(double x, double y, double w, double h) {
|
|
return false;
|
|
}
|
|
public boolean contains(Rectangle2D r) {
|
|
return false;
|
|
}
|
|
public PathIterator getPathIterator(AffineTransform at) {
|
|
return new PathIterator() {
|
|
public int getWindingRule() {
|
|
return windingrule;
|
|
}
|
|
public boolean isDone() {
|
|
return true;
|
|
}
|
|
public void next() {}
|
|
public int currentSegment(float[] coords) {
|
|
throw new NoSuchElementException();
|
|
}
|
|
public int currentSegment(double[] coords) {
|
|
throw new NoSuchElementException();
|
|
}
|
|
};
|
|
}
|
|
public PathIterator getPathIterator(AffineTransform at,
|
|
double flatness)
|
|
{
|
|
return getPathIterator(at);
|
|
}
|
|
}
|
|
|
|
public static class SampleShape implements Shape {
|
|
int windingrule;
|
|
int theTypes[];
|
|
double theCoords[];
|
|
int numTypes;
|
|
int numCoords;
|
|
|
|
public SampleShape(int windingrule,
|
|
int types[], double coords[],
|
|
int numtypes, int numcoords)
|
|
{
|
|
this.windingrule = windingrule;
|
|
this.theTypes = types;
|
|
this.theCoords = coords;
|
|
this.numTypes = numtypes;
|
|
this.numCoords = numcoords;
|
|
}
|
|
|
|
private Shape testshape;
|
|
|
|
public Shape getTestShape() {
|
|
if (testshape == null) {
|
|
testshape = new Area(this);
|
|
}
|
|
return testshape;
|
|
}
|
|
|
|
private Rectangle2D cachedBounds;
|
|
public Rectangle2D getCachedBounds2D() {
|
|
if (cachedBounds == null) {
|
|
double xmin, ymin, xmax, ymax;
|
|
int ci = 0;
|
|
xmin = xmax = theCoords[ci++];
|
|
ymin = ymax = theCoords[ci++];
|
|
while (ci < numCoords) {
|
|
double c = theCoords[ci++];
|
|
if (xmin > c) xmin = c;
|
|
if (xmax < c) xmax = c;
|
|
c = theCoords[ci++];
|
|
if (ymin > c) ymin = c;
|
|
if (ymax < c) ymax = c;
|
|
}
|
|
cachedBounds = new Rectangle2D.Double(xmin, ymin,
|
|
xmax - xmin,
|
|
ymax - ymin);
|
|
}
|
|
return cachedBounds;
|
|
}
|
|
|
|
public Rectangle getBounds() {
|
|
return getCachedBounds2D().getBounds();
|
|
}
|
|
public Rectangle2D getBounds2D() {
|
|
return getCachedBounds2D().getBounds2D();
|
|
}
|
|
public boolean contains(double x, double y) {
|
|
return getTestShape().contains(x, y);
|
|
}
|
|
public boolean contains(Point2D p) {
|
|
return getTestShape().contains(p);
|
|
}
|
|
public boolean intersects(double x, double y, double w, double h) {
|
|
return getTestShape().intersects(x, y, w, h);
|
|
}
|
|
public boolean intersects(Rectangle2D r) {
|
|
return getTestShape().intersects(r);
|
|
}
|
|
public boolean contains(double x, double y, double w, double h) {
|
|
return getTestShape().contains(x, y, w, h);
|
|
}
|
|
public boolean contains(Rectangle2D r) {
|
|
return getTestShape().contains(r);
|
|
}
|
|
public PathIterator getPathIterator(final AffineTransform at) {
|
|
return new PathIterator() {
|
|
int tindex;
|
|
int cindex;
|
|
public int getWindingRule() {
|
|
return windingrule;
|
|
}
|
|
public boolean isDone() {
|
|
return (tindex >= numTypes);
|
|
}
|
|
public void next() {
|
|
cindex += CoordsForType[theTypes[tindex]];
|
|
tindex++;
|
|
}
|
|
public int currentSegment(float[] coords) {
|
|
int t = theTypes[tindex];
|
|
int n = CoordsForType[t];
|
|
if (n > 0) {
|
|
// Cast to float first, then transform
|
|
// to match accuracy of float paths
|
|
for (int i = 0; i < n; i++) {
|
|
coords[i] = (float) theCoords[cindex+i];
|
|
}
|
|
if (at != null) {
|
|
at.transform(coords, 0, coords, 0, n/2);
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
public int currentSegment(double[] coords) {
|
|
int t = theTypes[tindex];
|
|
int n = CoordsForType[t];
|
|
if (n > 0) {
|
|
if (at == null) {
|
|
System.arraycopy(theCoords, cindex,
|
|
coords, 0, n);
|
|
} else {
|
|
at.transform(theCoords, cindex,
|
|
coords, 0, n/2);
|
|
}
|
|
}
|
|
return t;
|
|
}
|
|
};
|
|
}
|
|
public PathIterator getPathIterator(AffineTransform at,
|
|
double flatness)
|
|
{
|
|
return new FlatteningPathIterator(getPathIterator(at), flatness);
|
|
}
|
|
|
|
public String toString() {
|
|
Rectangle2D r2d = getBounds2D();
|
|
double xmin = r2d.getMinX();
|
|
double ymin = r2d.getMinY();
|
|
double xmax = r2d.getMaxX();
|
|
double ymax = r2d.getMaxY();
|
|
return ("SampleShape["+
|
|
(windingrule == WIND_NON_ZERO
|
|
? "NonZero"
|
|
: "EvenOdd")+
|
|
", nsegments = "+numTypes+
|
|
", ncoords = "+numCoords+
|
|
", bounds["+(r2d.getMinX()+", "+r2d.getMinY()+", "+
|
|
r2d.getMaxX()+", "+r2d.getMaxY())+"]"+
|
|
"]");
|
|
}
|
|
|
|
public Path2D makeFloatPath(Creator c) {
|
|
Path2D.Float p2df = (Path2D.Float) c.makePath(windingrule);
|
|
int ci = 0;
|
|
for (int i = 0; i < numTypes; i++) {
|
|
int t = theTypes[i];
|
|
switch (t) {
|
|
case PathIterator.SEG_MOVETO:
|
|
p2df.moveTo((float) theCoords[ci++],
|
|
(float) theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_LINETO:
|
|
p2df.lineTo((float) theCoords[ci++],
|
|
(float) theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_QUADTO:
|
|
p2df.quadTo((float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_CUBICTO:
|
|
p2df.curveTo((float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++],
|
|
(float) theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_CLOSE:
|
|
p2df.closePath();
|
|
break;
|
|
default:
|
|
throw new InternalError("unrecognized path type: "+t);
|
|
}
|
|
if (t != PathIterator.SEG_CLOSE) {
|
|
Point2D curpnt = p2df.getCurrentPoint();
|
|
if (((float) curpnt.getX()) != ((float) theCoords[ci-2]) ||
|
|
((float) curpnt.getY()) != ((float) theCoords[ci-1]))
|
|
{
|
|
throw new RuntimeException("currentpoint failed");
|
|
}
|
|
}
|
|
}
|
|
if (ci != numCoords) {
|
|
throw new InternalError("numcoords did not match");
|
|
}
|
|
return p2df;
|
|
}
|
|
|
|
public Path2D makeDoublePath(Creator c) {
|
|
Path2D p2d = c.makePath(windingrule);
|
|
int ci = 0;
|
|
for (int i = 0; i < numTypes; i++) {
|
|
int t = theTypes[i];
|
|
switch (t) {
|
|
case PathIterator.SEG_MOVETO:
|
|
p2d.moveTo(theCoords[ci++], theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_LINETO:
|
|
p2d.lineTo(theCoords[ci++], theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_QUADTO:
|
|
p2d.quadTo(theCoords[ci++], theCoords[ci++],
|
|
theCoords[ci++], theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_CUBICTO:
|
|
p2d.curveTo(theCoords[ci++], theCoords[ci++],
|
|
theCoords[ci++], theCoords[ci++],
|
|
theCoords[ci++], theCoords[ci++]);
|
|
break;
|
|
case PathIterator.SEG_CLOSE:
|
|
p2d.closePath();
|
|
break;
|
|
default:
|
|
throw new InternalError("unrecognized path type: "+t);
|
|
}
|
|
if (t != PathIterator.SEG_CLOSE) {
|
|
Point2D curpnt = p2d.getCurrentPoint();
|
|
if (((float) curpnt.getX()) != ((float) theCoords[ci-2]) ||
|
|
((float) curpnt.getY()) != ((float) theCoords[ci-1]))
|
|
{
|
|
throw new RuntimeException("currentpoint failed");
|
|
}
|
|
}
|
|
}
|
|
if (ci != numCoords) {
|
|
throw new InternalError("numcoords did not match");
|
|
}
|
|
return p2d;
|
|
}
|
|
}
|
|
|
|
public static class AppendedShape implements Shape {
|
|
Shape s1;
|
|
Shape s2;
|
|
boolean connect;
|
|
|
|
public AppendedShape(Shape s1, Shape s2, boolean connect) {
|
|
this.s1 = s1;
|
|
this.s2 = s2;
|
|
this.connect = connect;
|
|
}
|
|
|
|
public Rectangle getBounds() {
|
|
return getBounds2D().getBounds();
|
|
}
|
|
|
|
public Rectangle2D getBounds2D() {
|
|
return s1.getBounds2D().createUnion(s2.getBounds2D());
|
|
}
|
|
|
|
private Shape testshape;
|
|
private Shape getTestShape() {
|
|
if (testshape == null) {
|
|
testshape = new GeneralPath(this);
|
|
}
|
|
return testshape;
|
|
}
|
|
|
|
public boolean contains(double x, double y) {
|
|
return getTestShape().contains(x, y);
|
|
}
|
|
|
|
public boolean contains(Point2D p) {
|
|
return getTestShape().contains(p);
|
|
}
|
|
|
|
public boolean intersects(double x, double y, double w, double h) {
|
|
return getTestShape().intersects(x, y, w, h);
|
|
}
|
|
|
|
public boolean intersects(Rectangle2D r) {
|
|
return getTestShape().intersects(r);
|
|
}
|
|
|
|
public boolean contains(double x, double y, double w, double h) {
|
|
return getTestShape().contains(x, y, w, h);
|
|
}
|
|
|
|
public boolean contains(Rectangle2D r) {
|
|
return getTestShape().contains(r);
|
|
}
|
|
|
|
public PathIterator getPathIterator(final AffineTransform at) {
|
|
return new AppendingPathIterator(s1, s2, connect, at);
|
|
}
|
|
|
|
public PathIterator getPathIterator(AffineTransform at,
|
|
double flatness)
|
|
{
|
|
return new FlatteningPathIterator(getPathIterator(at), flatness);
|
|
}
|
|
|
|
public static class AppendingPathIterator implements PathIterator {
|
|
AffineTransform at;
|
|
PathIterator pi;
|
|
Shape swaiting;
|
|
int windingrule;
|
|
boolean connectrequested;
|
|
boolean canconnect;
|
|
boolean converttoline;
|
|
|
|
public AppendingPathIterator(Shape s1, Shape s2,
|
|
boolean connect,
|
|
AffineTransform at)
|
|
{
|
|
this.at = at;
|
|
this.pi = s1.getPathIterator(at);
|
|
this.swaiting = s2;
|
|
this.windingrule = pi.getWindingRule();
|
|
this.connectrequested = connect;
|
|
|
|
if (pi.isDone()) {
|
|
chain();
|
|
}
|
|
}
|
|
|
|
public void chain() {
|
|
if (swaiting != null) {
|
|
pi = swaiting.getPathIterator(at);
|
|
swaiting = null;
|
|
converttoline = (connectrequested && canconnect);
|
|
}
|
|
}
|
|
|
|
public int getWindingRule() {
|
|
return windingrule;
|
|
}
|
|
|
|
public boolean isDone() {
|
|
return (pi.isDone());
|
|
}
|
|
|
|
public void next() {
|
|
converttoline = false;
|
|
pi.next();
|
|
if (pi.isDone()) {
|
|
chain();
|
|
}
|
|
canconnect = true;
|
|
}
|
|
|
|
public int currentSegment(float[] coords) {
|
|
int type = pi.currentSegment(coords);
|
|
if (converttoline) {
|
|
type = SEG_LINETO;
|
|
}
|
|
return type;
|
|
}
|
|
|
|
public int currentSegment(double[] coords) {
|
|
int type = pi.currentSegment(coords);
|
|
if (converttoline) {
|
|
type = SEG_LINETO;
|
|
}
|
|
return type;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void checkEmpty(Path2D p2d, int windingrule) {
|
|
checkEmpty2(p2d, windingrule);
|
|
p2d.setWindingRule(PathIterator.WIND_NON_ZERO);
|
|
checkEmpty2(p2d, PathIterator.WIND_NON_ZERO);
|
|
p2d.setWindingRule(PathIterator.WIND_EVEN_ODD);
|
|
checkEmpty2(p2d, PathIterator.WIND_EVEN_ODD);
|
|
}
|
|
|
|
public static void checkEmpty2(Path2D p2d, int windingrule) {
|
|
if (p2d.getWindingRule() != windingrule) {
|
|
throw new RuntimeException("wrong winding rule in Path2D");
|
|
}
|
|
PathIterator pi = p2d.getPathIterator(null);
|
|
if (pi.getWindingRule() != windingrule) {
|
|
throw new RuntimeException("wrong winding rule in iterator");
|
|
}
|
|
if (!pi.isDone()) {
|
|
throw new RuntimeException("path not empty");
|
|
}
|
|
}
|
|
|
|
public static void compare(Creator c, Path2D p2d, Shape ref, int maxulp) {
|
|
compare(c, p2d, (Shape) p2d.clone(), null, 0);
|
|
compare(c, p2d, ref, null, 0);
|
|
compare(c, p2d, ref, TxIdentity, 0);
|
|
p2d.transform(TxIdentity);
|
|
compare(c, p2d, ref, null, 0);
|
|
compare(c, p2d, ref, TxIdentity, 0);
|
|
Shape s2 = p2d.createTransformedShape(TxIdentity);
|
|
compare(c, s2, ref, null, 0);
|
|
compare(c, s2, ref, TxIdentity, 0);
|
|
s2 = p2d.createTransformedShape(TxComplex);
|
|
compare(c, s2, ref, TxComplex, maxulp);
|
|
p2d.transform(TxComplex);
|
|
compare(c, p2d, (Shape) p2d.clone(), null, 0);
|
|
compare(c, p2d, ref, TxComplex, maxulp);
|
|
}
|
|
|
|
public static void compare(Creator c,
|
|
Shape p2d, Shape s,
|
|
AffineTransform at, int maxulp)
|
|
{
|
|
c.compare(p2d.getPathIterator(null), s.getPathIterator(at),
|
|
null, maxulp);
|
|
c.compare(p2d.getPathIterator(null), s.getPathIterator(null),
|
|
at, maxulp);
|
|
}
|
|
|
|
public static void checkBounds(Shape stest, Shape sref) {
|
|
checkBounds(stest.getBounds2D(), sref.getBounds2D(),
|
|
"2D bounds too small");
|
|
/*
|
|
checkBounds(stest.getBounds(), sref.getBounds(),
|
|
"int bounds too small");
|
|
*/
|
|
checkBounds(stest.getBounds(), stest.getBounds2D(),
|
|
"int bounds too small for 2D bounds");
|
|
}
|
|
|
|
public static void checkBounds(Rectangle2D tBounds,
|
|
Rectangle2D rBounds,
|
|
String faildesc)
|
|
{
|
|
if (rBounds.isEmpty()) {
|
|
if (!tBounds.isEmpty()) {
|
|
throw new RuntimeException("bounds not empty");
|
|
}
|
|
return;
|
|
} else if (tBounds.isEmpty()) {
|
|
throw new RuntimeException("bounds empty");
|
|
}
|
|
double rxmin = rBounds.getMinX();
|
|
double rymin = rBounds.getMinY();
|
|
double rxmax = rBounds.getMaxX();
|
|
double rymax = rBounds.getMaxY();
|
|
double txmin = tBounds.getMinX();
|
|
double tymin = tBounds.getMinY();
|
|
double txmax = tBounds.getMaxX();
|
|
double tymax = tBounds.getMaxY();
|
|
if (txmin > rxmin || tymin > rymin ||
|
|
txmax < rxmax || tymax < rymax)
|
|
{
|
|
if (verbose) System.out.println("test bounds = "+tBounds);
|
|
if (verbose) System.out.println("ref bounds = "+rBounds);
|
|
// Allow fudge room of a couple of single precision ulps
|
|
double ltxmin = txmin - 5 * Math.max(Math.ulp((float) rxmin),
|
|
Math.ulp((float) txmin));
|
|
double ltymin = tymin - 5 * Math.max(Math.ulp((float) rymin),
|
|
Math.ulp((float) tymin));
|
|
double ltxmax = txmax + 5 * Math.max(Math.ulp((float) rxmax),
|
|
Math.ulp((float) txmax));
|
|
double ltymax = tymax + 5 * Math.max(Math.ulp((float) rymax),
|
|
Math.ulp((float) tymax));
|
|
if (ltxmin > rxmin || ltymin > rymin ||
|
|
ltxmax < rxmax || ltymax < rymax)
|
|
{
|
|
if (!verbose) System.out.println("test bounds = "+tBounds);
|
|
if (!verbose) System.out.println("ref bounds = "+rBounds);
|
|
System.out.println("xmin: "+
|
|
txmin+" + "+fltulpless(txmin, rxmin)+" = "+
|
|
rxmin+" + "+fltulpless(rxmin, txmin));
|
|
System.out.println("ymin: "+
|
|
tymin+" + "+fltulpless(tymin, rymin)+" = "+
|
|
rymin+" + "+fltulpless(rymin, tymin));
|
|
System.out.println("xmax: "+
|
|
txmax+" + "+fltulpless(txmax, rxmax)+" = "+
|
|
rxmax+" + "+fltulpless(rxmax, txmax));
|
|
System.out.println("ymax: "+
|
|
tymax+" + "+fltulpless(tymax, rymax)+" = "+
|
|
rymax+" + "+fltulpless(rymax, tymax));
|
|
System.out.println("flt tbounds = ["+
|
|
((float) txmin)+", "+((float) tymin)+", "+
|
|
((float) txmax)+", "+((float) tymax)+"]");
|
|
System.out.println("flt rbounds = ["+
|
|
((float) rxmin)+", "+((float) rymin)+", "+
|
|
((float) rxmax)+", "+((float) rymax)+"]");
|
|
System.out.println("xmin ulp = "+fltulpless(rxmin, txmin));
|
|
System.out.println("ymin ulp = "+fltulpless(rymin, tymin));
|
|
System.out.println("xmax ulp = "+fltulpless(txmax, rxmax));
|
|
System.out.println("ymax ulp = "+fltulpless(tymax, rymax));
|
|
throw new RuntimeException(faildesc);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void checkHits(Shape stest, Shape sref) {
|
|
for (int i = 0; i < 10; i++) {
|
|
double px = Math.random() * 500 - 250;
|
|
double py = Math.random() * 500 - 250;
|
|
Point2D pnt = new Point2D.Double(px, py);
|
|
|
|
double rw = Math.random()*10+0.4;
|
|
double rh = Math.random()*10+0.4;
|
|
double rx = px - rw/2;
|
|
double ry = py - rh/2;
|
|
Rectangle2D rect = new Rectangle2D.Double(rx, ry, rw, rh);
|
|
Rectangle2D empty = new Rectangle2D.Double(rx, ry, 0, 0);
|
|
|
|
if (!rect.contains(pnt)) {
|
|
throw new InternalError("test point not inside test rect!");
|
|
}
|
|
|
|
if (stest.contains(rx, ry, 0, 0)) {
|
|
throw new RuntimeException("contains 0x0 rect");
|
|
}
|
|
if (stest.contains(empty)) {
|
|
throw new RuntimeException("contains empty rect");
|
|
}
|
|
if (stest.intersects(rx, ry, 0, 0)) {
|
|
throw new RuntimeException("intersects 0x0 rect");
|
|
}
|
|
if (stest.intersects(empty)) {
|
|
throw new RuntimeException("intersects empty rect");
|
|
}
|
|
|
|
boolean tContainsXY = stest.contains(px, py);
|
|
boolean tContainsPnt = stest.contains(pnt);
|
|
boolean tContainsXYWH = stest.contains(rx, ry, rw, rh);
|
|
boolean tContainsRect = stest.contains(rect);
|
|
boolean tIntersectsXYWH = stest.intersects(rx, ry, rw, rh);
|
|
boolean tIntersectsRect = stest.intersects(rect);
|
|
|
|
if (tContainsXY != tContainsPnt) {
|
|
throw new RuntimeException("contains(x,y) != "+
|
|
"contains(pnt)");
|
|
}
|
|
if (tContainsXYWH != tContainsRect) {
|
|
throw new RuntimeException("contains(x,y,w,h) != "+
|
|
"contains(rect)");
|
|
}
|
|
if (tIntersectsXYWH != tIntersectsRect) {
|
|
throw new RuntimeException("intersects(x,y,w,h) != "+
|
|
"intersects(rect)");
|
|
}
|
|
|
|
boolean uContainsXY =
|
|
Path2D.contains(stest.getPathIterator(null), px, py);
|
|
boolean uContainsXYWH =
|
|
Path2D.contains(stest.getPathIterator(null), rx, ry, rw, rh);
|
|
boolean uIntersectsXYWH =
|
|
Path2D.intersects(stest.getPathIterator(null), rx, ry, rw, rh);
|
|
|
|
if (tContainsXY != uContainsXY) {
|
|
throw new RuntimeException("contains(x,y) "+
|
|
"does not match utility");
|
|
}
|
|
if (tContainsXYWH != uContainsXYWH) {
|
|
throw new RuntimeException("contains(x,y,w,h) "+
|
|
"does not match utility");
|
|
}
|
|
if (tIntersectsXYWH != uIntersectsXYWH) {
|
|
throw new RuntimeException("intersects(x,y,w,h) "+
|
|
"does not match utility");
|
|
}
|
|
|
|
// Make rect slightly smaller to be more conservative for rContains
|
|
double srx = rx + 0.1;
|
|
double sry = ry + 0.1;
|
|
double srw = rw - 0.2;
|
|
double srh = rh - 0.2;
|
|
Rectangle2D srect = new Rectangle2D.Double(srx, sry, srw, srh);
|
|
// Make rect slightly larger to be more liberal for rIntersects
|
|
double lrx = rx - 0.1;
|
|
double lry = ry - 0.1;
|
|
double lrw = rw + 0.2;
|
|
double lrh = rh + 0.2;
|
|
Rectangle2D lrect = new Rectangle2D.Double(lrx, lry, lrw, lrh);
|
|
|
|
if (srect.isEmpty()) {
|
|
throw new InternalError("smaller rect too small (empty)");
|
|
}
|
|
if (!lrect.contains(rect)) {
|
|
throw new InternalError("test rect not inside larger rect!");
|
|
}
|
|
if (!rect.contains(srect)) {
|
|
throw new InternalError("smaller rect not inside test rect!");
|
|
}
|
|
|
|
boolean rContainsSmaller;
|
|
boolean rIntersectsLarger;
|
|
boolean rContainsPnt;
|
|
|
|
if (sref instanceof SampleShape ||
|
|
sref instanceof QuadCurve2D ||
|
|
sref instanceof CubicCurve2D)
|
|
{
|
|
// REMIND
|
|
// Some of the source shapes are not proving reliable
|
|
// enough to do reference verification of the hit
|
|
// testing results.
|
|
// Quad/CubicCurve2D have spaghetti test methods that could
|
|
// very likely contain some bugs. They return a conflicting
|
|
// answer in maybe 1 out of 20,000 tests.
|
|
// Area causes a conflicting answer maybe 1 out of
|
|
// 100 to 1000 runs and it infinite loops maybe 1
|
|
// out of 10,000 runs or so.
|
|
// So, we use some conservative "safe" answers for
|
|
// these shapes and avoid their hit testing methods.
|
|
rContainsSmaller = tContainsRect;
|
|
rIntersectsLarger = tIntersectsRect;
|
|
rContainsPnt = tContainsPnt;
|
|
} else {
|
|
rContainsSmaller = sref.contains(srect);
|
|
rIntersectsLarger = sref.intersects(lrect);
|
|
rContainsPnt = sref.contains(px, py);
|
|
}
|
|
|
|
if (tIntersectsRect) {
|
|
if (tContainsRect) {
|
|
if (!tContainsPnt) {
|
|
System.out.println("reference shape = "+sref);
|
|
System.out.println("pnt = "+pnt);
|
|
System.out.println("rect = "+rect);
|
|
System.out.println("tbounds = "+stest.getBounds2D());
|
|
throw new RuntimeException("test contains rect, "+
|
|
"but not center point");
|
|
}
|
|
}
|
|
// Note: (tContainsPnt || tContainsRect) is same as
|
|
// tContainsPnt because of the test above...
|
|
if (tContainsPnt) {
|
|
if (!rIntersectsLarger) {
|
|
System.out.println("reference shape = "+sref);
|
|
System.out.println("pnt = "+pnt);
|
|
System.out.println("rect = "+rect);
|
|
System.out.println("lrect = "+lrect);
|
|
System.out.println("tbounds = "+stest.getBounds2D());
|
|
System.out.println("rbounds = "+sref.getBounds2D());
|
|
throw new RuntimeException("test claims containment, "+
|
|
"but no ref intersection");
|
|
}
|
|
}
|
|
} else {
|
|
if (tContainsRect) {
|
|
throw new RuntimeException("test contains rect, "+
|
|
"with no intersection");
|
|
}
|
|
if (tContainsPnt) {
|
|
System.out.println("reference shape = "+sref);
|
|
System.out.println("rect = "+rect);
|
|
throw new RuntimeException("test contains point, "+
|
|
"with no intersection");
|
|
}
|
|
if (rContainsPnt || rContainsSmaller) {
|
|
System.out.println("pnt = "+pnt);
|
|
System.out.println("rect = "+rect);
|
|
System.out.println("srect = "+lrect);
|
|
throw new RuntimeException("test did not intersect, "+
|
|
"but ref claims containment");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void test(Creator c) {
|
|
testConstructors(c);
|
|
testPathConstruction(c);
|
|
testAppend(c);
|
|
testBounds(c);
|
|
testHits(c);
|
|
}
|
|
|
|
public static void testConstructors(Creator c) {
|
|
checkEmpty(c.makePath(), WIND_NON_ZERO);
|
|
checkEmpty(c.makePath(WIND_NON_ZERO), WIND_NON_ZERO);
|
|
checkEmpty(c.makePath(WIND_EVEN_ODD), WIND_EVEN_ODD);
|
|
checkEmpty(c.makePath(EmptyShapeNonZero), WIND_NON_ZERO);
|
|
checkEmpty(c.makePath(EmptyShapeNonZero, null), WIND_NON_ZERO);
|
|
checkEmpty(c.makePath(EmptyShapeNonZero, TxIdentity), WIND_NON_ZERO);
|
|
checkEmpty(c.makePath(EmptyShapeEvenOdd), WIND_EVEN_ODD);
|
|
checkEmpty(c.makePath(EmptyShapeEvenOdd, null), WIND_EVEN_ODD);
|
|
checkEmpty(c.makePath(EmptyShapeEvenOdd, TxIdentity), WIND_EVEN_ODD);
|
|
try {
|
|
c.makePath(null);
|
|
throw new RuntimeException(c+" allowed null Shape in constructor");
|
|
} catch (NullPointerException npe) {
|
|
// passes
|
|
}
|
|
try {
|
|
c.makePath(null, TxIdentity);
|
|
throw new RuntimeException(c+" allowed null Shape in constructor");
|
|
} catch (NullPointerException npe) {
|
|
// passes
|
|
}
|
|
|
|
for (int i = 0; i < TestShapes.length; i++) {
|
|
Shape sref = TestShapes[i];
|
|
if (verbose) System.out.println("construct testing "+sref);
|
|
compare(c, c.makePath(sref), sref, null, 0);
|
|
compare(c, c.makePath(sref), sref, TxIdentity, 0);
|
|
compare(c, c.makePath(sref, null), sref, null, 0);
|
|
compare(c, c.makePath(sref, null), sref, TxIdentity, 0);
|
|
compare(c, c.makePath(sref, TxIdentity), sref, null, 0);
|
|
compare(c, c.makePath(sref, TxIdentity), sref, TxIdentity, 0);
|
|
compare(c, c.makePath(sref, TxComplex), sref, TxComplex,
|
|
c.getRecommendedTxMaxUlp());
|
|
}
|
|
}
|
|
|
|
public static void testPathConstruction(Creator c) {
|
|
testPathConstruction(c, LongSampleNonZero);
|
|
testPathConstruction(c, LongSampleEvenOdd);
|
|
}
|
|
|
|
public static void testPathConstruction(Creator c, SampleShape ref) {
|
|
if (c.supportsFloatCompose()) {
|
|
compare(c, ref.makeFloatPath(c), ref, c.getRecommendedTxMaxUlp());
|
|
}
|
|
compare(c, ref.makeDoublePath(c), ref, c.getRecommendedTxMaxUlp());
|
|
}
|
|
|
|
public static void testAppend(Creator c) {
|
|
for (int i = 0; i < TestShapes.length; i++) {
|
|
Shape sref = TestShapes[i];
|
|
if (verbose) System.out.println("append testing "+sref);
|
|
PathIterator spi = sref.getPathIterator(null);
|
|
Path2D stest = c.makePath(spi.getWindingRule());
|
|
stest.append(spi, false);
|
|
compare(c, stest, sref, null, 0);
|
|
stest.reset();
|
|
stest.append(sref, false);
|
|
compare(c, stest, sref, null, 0);
|
|
stest.reset();
|
|
stest.append(sref.getPathIterator(TxComplex), false);
|
|
compare(c, stest, sref, TxComplex, 0);
|
|
// multiple shape append testing...
|
|
if (sref.getBounds2D().isEmpty()) {
|
|
// If the first shape is empty, then we really
|
|
// are not testing multiple appended shapes,
|
|
// we are just testing appending the AppendShape
|
|
// to a null path over and over.
|
|
// Also note that some empty shapes will spit out
|
|
// a single useless SEG_MOVETO that has no affect
|
|
// on the outcome, but it makes duplicating the
|
|
// behavior that Path2D has in that case difficult
|
|
// when the AppenedShape utility class has to
|
|
// iterate the exact same segments. So, we will
|
|
// just ignore all empty shapes here.
|
|
continue;
|
|
}
|
|
stest.reset();
|
|
stest.append(sref, false);
|
|
stest.append(AppendShape, false);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, false),
|
|
null, 0);
|
|
stest.reset();
|
|
stest.append(sref, false);
|
|
stest.append(AppendShape, true);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, true),
|
|
null, 0);
|
|
stest.reset();
|
|
stest.append(sref.getPathIterator(null), false);
|
|
stest.append(AppendShape.getPathIterator(null), false);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, false),
|
|
null, 0);
|
|
stest.reset();
|
|
stest.append(sref.getPathIterator(null), false);
|
|
stest.append(AppendShape.getPathIterator(null), true);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, true),
|
|
null, 0);
|
|
stest.reset();
|
|
stest.append(sref.getPathIterator(TxComplex), false);
|
|
stest.append(AppendShape.getPathIterator(TxComplex), false);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, false),
|
|
TxComplex, 0);
|
|
stest.reset();
|
|
stest.append(sref.getPathIterator(TxComplex), false);
|
|
stest.append(AppendShape.getPathIterator(TxComplex), true);
|
|
compare(c, stest,
|
|
new AppendedShape(sref, AppendShape, true),
|
|
TxComplex, 0);
|
|
}
|
|
}
|
|
|
|
public static void testBounds(Creator c) {
|
|
for (int i = 0; i < TestShapes.length; i++) {
|
|
Shape sref = TestShapes[i];
|
|
if (verbose) System.out.println("bounds testing "+sref);
|
|
Shape stest = c.makePath(sref);
|
|
checkBounds(c.makePath(sref), sref);
|
|
}
|
|
testBounds(c, ShortSampleNonZero);
|
|
testBounds(c, ShortSampleEvenOdd);
|
|
testBounds(c, LongSampleNonZero);
|
|
testBounds(c, LongSampleEvenOdd);
|
|
}
|
|
|
|
public static void testBounds(Creator c, SampleShape ref) {
|
|
if (verbose) System.out.println("bounds testing "+ref);
|
|
if (c.supportsFloatCompose()) {
|
|
checkBounds(ref.makeFloatPath(c), ref);
|
|
}
|
|
checkBounds(ref.makeDoublePath(c), ref);
|
|
}
|
|
|
|
public static void testHits(Creator c) {
|
|
for (int i = 0; i < TestShapes.length; i++) {
|
|
Shape sref = TestShapes[i];
|
|
if (verbose) System.out.println("hit testing "+sref);
|
|
Shape stest = c.makePath(sref);
|
|
checkHits(c.makePath(sref), sref);
|
|
}
|
|
testHits(c, ShortSampleNonZero);
|
|
testHits(c, ShortSampleEvenOdd);
|
|
// These take too long to construct the Area for reference testing
|
|
//testHits(c, LongSampleNonZero);
|
|
//testHits(c, LongSampleEvenOdd);
|
|
}
|
|
|
|
public static void testHits(Creator c, SampleShape ref) {
|
|
if (verbose) System.out.println("hit testing "+ref);
|
|
if (c.supportsFloatCompose()) {
|
|
checkHits(ref.makeFloatPath(c), ref);
|
|
}
|
|
checkHits(ref.makeDoublePath(c), ref);
|
|
}
|
|
|
|
public static void main(String argv[]) {
|
|
int limit = (argv.length > 0) ? 10000 : 1;
|
|
verbose = (argv.length > 1);
|
|
for (int i = 0; i < limit; i++) {
|
|
if (limit > 1) {
|
|
System.out.println("loop #"+(i+1));
|
|
}
|
|
init();
|
|
test(new GPCreator());
|
|
test(new FltCreator());
|
|
test(new DblCreator());
|
|
}
|
|
}
|
|
}
|