7033660: Update copyright year to 2011 on any files changed in 2011
Reviewed-by: dholmes
/*
* Copyright (c) 2008, 2010, 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 6766342
* @summary Tests clipping invariance for AA rectangle and line primitives
* @run main RenderClipTest -strict -readfile 6766342.tests
* @run main RenderClipTest -rectsuite -count 10
*/
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.awt.event.*;
import java.util.Vector;
import java.io.*;
public class RenderClipTest {
public static double randDblCoord() {
return Math.random()*60 - 10;
}
public static float randFltCoord() {
return (float) randDblCoord();
}
public static int randIntCoord() {
return (int) Math.round(randDblCoord());
}
public static int randInt(int n) {
return ((int) (Math.random() * (n*4))) >> 2;
}
static int numtests;
static int numerrors;
static int numfillfailures;
static int numstrokefailures;
static int maxerr;
static boolean useAA;
static boolean strokePure;
static boolean testFill;
static boolean testDraw;
static boolean silent;
static boolean verbose;
static boolean strict;
static boolean showErrors;
static float lw;
static double rot;
static BufferedImage imgref;
static BufferedImage imgtst;
static Graphics2D grefclear;
static Graphics2D gtstclear;
static Graphics2D grefrender;
static Graphics2D gtstrender;
public static abstract class AnnotatedRenderOp {
public static AnnotatedRenderOp parse(String str) {
AnnotatedRenderOp ar;
if (((ar = Cubic.tryparse(str)) != null) ||
((ar = Quad.tryparse(str)) != null) ||
((ar = Poly.tryparse(str)) != null) ||
((ar = Path.tryparse(str)) != null) ||
((ar = Rect.tryparse(str)) != null) ||
((ar = Line.tryparse(str)) != null) ||
((ar = RectMethod.tryparse(str)) != null) ||
((ar = LineMethod.tryparse(str)) != null))
{
return ar;
}
System.err.println("Unable to parse shape: "+str);
return null;
}
public abstract void randomize();
public abstract void fill(Graphics2D g2d);
public abstract void draw(Graphics2D g2d);
}
public static abstract class AnnotatedShapeOp extends AnnotatedRenderOp {
public abstract Shape getShape();
public void fill(Graphics2D g2d) {
g2d.fill(getShape());
}
public void draw(Graphics2D g2d) {
g2d.draw(getShape());
}
}
public static void usage(String err) {
if (err != null) {
System.err.println(err);
}
System.err.println("usage: java RenderClipTest "+
"[-read[file F]] [-rectsuite] [-fill] [-draw]");
System.err.println(" "+
"[-aa] [-pure] [-lw N] [-rot N]");
System.err.println(" "+
"[-rectmethod] [-linemethod] [-rect] [-line]");
System.err.println(" "+
"[-cubic] [-quad] [-poly] [-path]");
System.err.println(" "+
"[-silent] [-verbose] [-showerr] [-count N]");
System.err.println(" "+
"[-strict] [-usage]");
System.err.println(" -read Read test data from stdin");
System.err.println(" -readfile F Read test data from file F");
System.err.println(" -rectsuite Run a suite of rect/line tests");
System.err.println(" -fill Test g.fill*(...)");
System.err.println(" -draw Test g.draw*(...)");
System.err.println(" -aa Use antialiased rendering");
System.err.println(" -pure Use STROKE_PURE hint");
System.err.println(" -lw N Test line widths of N "+
"(default 1.0)");
System.err.println(" -rot N Test rotation by N degrees "+
"(default 0.0)");
System.err.println(" -rectmethod Test fillRect/drawRect methods");
System.err.println(" -linemethod Test drawLine method");
System.err.println(" -rect Test Rectangle2D shapes");
System.err.println(" -line Test Line2D shapes");
System.err.println(" -cubic Test CubicCurve2D shapes");
System.err.println(" -quad Test QuadCurve2D shapes");
System.err.println(" -poly Test Polygon shapes");
System.err.println(" -path Test GeneralPath shapes");
System.err.println(" -silent Do not print out error curves");
System.err.println(" -verbose Print out progress info");
System.err.println(" -showerr Display errors on screen");
System.err.println(" -count N N tests per shape, then exit "+
"(default 1000)");
System.err.println(" -strict All failures are important");
System.err.println(" -usage Print this help, then exit");
System.exit((err != null) ? -1 : 0);
}
public static void main(String argv[]) {
boolean readTests = false;
String readFile = null;
boolean rectsuite = false;
int count = 1000;
lw = 1.0f;
rot = 0.0;
Vector<AnnotatedRenderOp> testOps = new Vector<AnnotatedRenderOp>();
for (int i = 0; i < argv.length; i++) {
String arg = argv[i].toLowerCase();
if (arg.equals("-aa")) {
useAA = true;
} else if (arg.equals("-pure")) {
strokePure = true;
} else if (arg.equals("-fill")) {
testFill = true;
} else if (arg.equals("-draw")) {
testDraw = true;
} else if (arg.equals("-lw")) {
if (i+1 >= argv.length) {
usage("Missing argument: "+argv[i]);
}
lw = Float.parseFloat(argv[++i]);
} else if (arg.equals("-rot")) {
if (i+1 >= argv.length) {
usage("Missing argument: "+argv[i]);
}
rot = Double.parseDouble(argv[++i]);
} else if (arg.equals("-cubic")) {
testOps.add(new Cubic());
} else if (arg.equals("-quad")) {
testOps.add(new Quad());
} else if (arg.equals("-poly")) {
testOps.add(new Poly());
} else if (arg.equals("-path")) {
testOps.add(new Path());
} else if (arg.equals("-rect")) {
testOps.add(new Rect());
} else if (arg.equals("-line")) {
testOps.add(new Line());
} else if (arg.equals("-rectmethod")) {
testOps.add(new RectMethod());
} else if (arg.equals("-linemethod")) {
testOps.add(new LineMethod());
} else if (arg.equals("-verbose")) {
verbose = true;
} else if (arg.equals("-strict")) {
strict = true;
} else if (arg.equals("-silent")) {
silent = true;
} else if (arg.equals("-showerr")) {
showErrors = true;
} else if (arg.equals("-readfile")) {
if (i+1 >= argv.length) {
usage("Missing argument: "+argv[i]);
}
readTests = true;
readFile = argv[++i];
} else if (arg.equals("-read")) {
readTests = true;
readFile = null;
} else if (arg.equals("-rectsuite")) {
rectsuite = true;
} else if (arg.equals("-count")) {
if (i+1 >= argv.length) {
usage("Missing argument: "+argv[i]);
}
count = Integer.parseInt(argv[++i]);
} else if (arg.equals("-usage")) {
usage(null);
} else {
usage("Unknown argument: "+argv[i]);
}
}
if (readTests) {
if (rectsuite || testDraw || testFill ||
useAA || strokePure ||
lw != 1.0f || rot != 0.0 ||
testOps.size() > 0)
{
usage("Should not specify test types with -read options");
}
} else if (rectsuite) {
if (testDraw || testFill ||
useAA || strokePure ||
lw != 1.0f || rot != 0.0 ||
testOps.size() > 0)
{
usage("Should not specify test types with -rectsuite option");
}
} else {
if (!testDraw && !testFill) {
usage("No work: Must specify one or both of "+
"-fill or -draw");
}
if (testOps.size() == 0) {
usage("No work: Must specify one or more of "+
"-rect[method], -line[method], "+
"-cubic, -quad, -poly, or -path");
}
}
initImages();
if (readTests) {
try {
InputStream is;
if (readFile == null) {
is = System.in;
} else {
File f =
new File(System.getProperty("test.src", "."),
readFile);
is = new FileInputStream(f);
}
parseAndRun(is);
} catch (IOException e) {
throw new RuntimeException(e);
}
} else if (rectsuite) {
runRectSuite(count);
} else {
initGCs();
for (int k = 0; k < testOps.size(); k++) {
AnnotatedRenderOp ar = testOps.get(k);
runRandomTests(ar, count);
}
disposeGCs();
}
grefclear.dispose();
gtstclear.dispose();
grefclear = gtstclear = null;
reportStatistics();
}
public static int reportStatistics() {
String connector = "";
if (numfillfailures > 0) {
System.out.print(numfillfailures+" fills ");
connector = "and ";
}
if (numstrokefailures > 0) {
System.out.print(connector+numstrokefailures+" strokes ");
}
int totalfailures = numfillfailures + numstrokefailures;
if (totalfailures == 0) {
System.out.print("0 ");
}
System.out.println("out of "+numtests+" tests failed...");
int critical = numerrors;
if (strict) {
critical += totalfailures;
}
if (critical > 0) {
throw new RuntimeException(critical+" tests had critical errors");
}
System.out.println("No tests had critical errors");
return (numerrors+totalfailures);
}
public static void runRectSuite(int count) {
AnnotatedRenderOp ops[] = {
new Rect(),
new RectMethod(),
new Line(),
new LineMethod(),
};
// Sometimes different fill algorithms are chosen for
// thin and wide line modes, make sure we test both...
float filllinewidths[] = { 0.0f, 2.0f };
float drawlinewidths[] = { 0.0f, 0.5f, 1.0f,
2.0f, 2.5f,
5.0f, 5.3f };
double rotations[] = { 0.0, 15.0, 90.0,
135.0, 180.0,
200.0, 270.0,
300.0};
for (AnnotatedRenderOp ar: ops) {
for (double r: rotations) {
rot = r;
for (int i = 0; i < 8; i++) {
float linewidths[];
if ((i & 1) == 0) {
if ((ar instanceof Line) ||
(ar instanceof LineMethod))
{
continue;
}
testFill = true;
testDraw = false;
linewidths = filllinewidths;
} else {
testFill = false;
testDraw = true;
linewidths = drawlinewidths;
}
useAA = ((i & 2) != 0);
strokePure = ((i & 4) != 0);
for (float w : linewidths) {
lw = w;
runSuiteTests(ar, count);
}
}
}
}
}
public static void runSuiteTests(AnnotatedRenderOp ar, int count) {
if (verbose) {
System.out.print("Running ");
System.out.print(testFill ? "Fill " : "Draw ");
System.out.print(BaseName(ar));
if (useAA) {
System.out.print(" AA");
}
if (strokePure) {
System.out.print(" Pure");
}
if (lw != 1.0f) {
System.out.print(" lw="+lw);
}
if (rot != 0.0f) {
System.out.print(" rot="+rot);
}
System.out.println();
}
initGCs();
runRandomTests(ar, count);
disposeGCs();
}
public static String BaseName(AnnotatedRenderOp ar) {
String s = ar.toString();
int leftparen = s.indexOf('(');
if (leftparen >= 0) {
s = s.substring(0, leftparen);
}
return s;
}
public static void runRandomTests(AnnotatedRenderOp ar, int count) {
for (int i = 0; i < count; i++) {
ar.randomize();
if (testDraw) {
test(ar, false);
}
if (testFill) {
test(ar, true);
}
}
}
public static void initImages() {
imgref = new BufferedImage(40, 40, BufferedImage.TYPE_INT_RGB);
imgtst = new BufferedImage(40, 40, BufferedImage.TYPE_INT_RGB);
grefclear = imgref.createGraphics();
gtstclear = imgtst.createGraphics();
grefclear.setColor(Color.white);
gtstclear.setColor(Color.white);
}
public static void initGCs() {
grefrender = imgref.createGraphics();
gtstrender = imgtst.createGraphics();
gtstrender.clipRect(10, 10, 20, 20);
grefrender.setColor(Color.blue);
gtstrender.setColor(Color.blue);
if (lw != 1.0f) {
BasicStroke bs = new BasicStroke(lw);
grefrender.setStroke(bs);
gtstrender.setStroke(bs);
}
if (rot != 0.0) {
double rotrad = Math.toRadians(rot);
grefrender.rotate(rotrad, 20, 20);
gtstrender.rotate(rotrad, 20, 20);
}
if (strokePure) {
grefrender.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
RenderingHints.VALUE_STROKE_PURE);
gtstrender.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
RenderingHints.VALUE_STROKE_PURE);
}
if (useAA) {
grefrender.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
gtstrender.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
maxerr = 1;
}
}
public static void disposeGCs() {
grefrender.dispose();
gtstrender.dispose();
grefrender = gtstrender = null;
}
public static void parseAndRun(InputStream in) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String str;
while ((str = br.readLine()) != null) {
if (str.startsWith("Stroked ") || str.startsWith("Filled ")) {
parseTest(str);
continue;
}
if (str.startsWith("Running ")) {
continue;
}
if (str.startsWith("Failed: ")) {
continue;
}
if (str.indexOf(" out of ") > 0 &&
str.indexOf(" tests failed...") > 0)
{
continue;
}
if (str.indexOf(" tests had critical errors") > 0) {
continue;
}
System.err.println("Unparseable line: "+str);
}
}
public static void parseTest(String origstr) {
String str = origstr;
boolean isfill = false;
useAA = strokePure = false;
lw = 1.0f;
rot = 0.0;
if (str.startsWith("Stroked ")) {
str = str.substring(8);
isfill = false;
} else if (str.startsWith("Filled ")) {
str = str.substring(7);
isfill = true;
} else {
System.err.println("Unparseable test line: "+origstr);
}
if (str.startsWith("AA ")) {
str = str.substring(3);
useAA = true;
}
if (str.startsWith("Pure ")) {
str = str.substring(5);
strokePure = true;
}
if (str.startsWith("Lw=")) {
int index = str.indexOf(' ', 3);
if (index > 0) {
lw = Float.parseFloat(str.substring(3, index));
str = str.substring(index+1);
}
}
if (str.startsWith("Rot=")) {
int index = str.indexOf(' ', 4);
if (index > 0) {
rot = Double.parseDouble(str.substring(4, index));
str = str.substring(index+1);
}
}
AnnotatedRenderOp ar = AnnotatedRenderOp.parse(str);
if (ar != null) {
initGCs();
test(ar, isfill);
disposeGCs();
} else {
System.err.println("Unparseable test line: "+origstr);
}
}
public static void test(AnnotatedRenderOp ar, boolean isfill) {
grefclear.fillRect(0, 0, 40, 40);
gtstclear.fillRect(0, 0, 40, 40);
if (isfill) {
ar.fill(grefrender);
ar.fill(gtstrender);
} else {
ar.draw(grefrender);
ar.draw(gtstrender);
}
check(imgref, imgtst, ar, isfill);
}
public static int[] getData(BufferedImage img) {
Raster r = img.getRaster();
DataBufferInt dbi = (DataBufferInt) r.getDataBuffer();
return dbi.getData();
}
public static int getScan(BufferedImage img) {
Raster r = img.getRaster();
SinglePixelPackedSampleModel sppsm =
(SinglePixelPackedSampleModel) r.getSampleModel();
return sppsm.getScanlineStride();
}
public static int getOffset(BufferedImage img) {
Raster r = img.getRaster();
SinglePixelPackedSampleModel sppsm =
(SinglePixelPackedSampleModel) r.getSampleModel();
return sppsm.getOffset(-r.getSampleModelTranslateX(),
-r.getSampleModelTranslateY());
}
final static int opaque = 0xff000000;
final static int whitergb = Color.white.getRGB();
public static final int maxdiff(int rgb1, int rgb2) {
int maxd = 0;
for (int i = 0; i < 32; i += 8) {
int c1 = (rgb1 >> i) & 0xff;
int c2 = (rgb2 >> i) & 0xff;
int d = Math.abs(c1-c2);
if (maxd < d) {
maxd = d;
}
}
return maxd;
}
public static void check(BufferedImage imgref, BufferedImage imgtst,
AnnotatedRenderOp ar, boolean wasfill)
{
numtests++;
int dataref[] = getData(imgref);
int datatst[] = getData(imgtst);
int scanref = getScan(imgref);
int scantst = getScan(imgtst);
int offref = getOffset(imgref);
int offtst = getOffset(imgtst);
// We want to check for errors outside the clip at a higher
// priority than errors involving different pixels touched
// inside the clip.
// Check above clip
if (check(ar, wasfill,
null, 0, 0,
datatst, scantst, offtst,
0, 0, 40, 10))
{
return;
}
// Check below clip
if (check(ar, wasfill,
null, 0, 0,
datatst, scantst, offtst,
0, 30, 40, 40))
{
return;
}
// Check left of clip
if (check(ar, wasfill,
null, 0, 0,
datatst, scantst, offtst,
0, 10, 10, 30))
{
return;
}
// Check right of clip
if (check(ar, wasfill,
null, 0, 0,
datatst, scantst, offtst,
30, 10, 40, 30))
{
return;
}
// Check inside clip
check(ar, wasfill,
dataref, scanref, offref,
datatst, scantst, offtst,
10, 10, 30, 30);
}
public static boolean check(AnnotatedRenderOp ar, boolean wasfill,
int dataref[], int scanref, int offref,
int datatst[], int scantst, int offtst,
int x0, int y0, int x1, int y1)
{
offref += scanref * y0;
offtst += scantst * y0;
for (int y = y0; y < y1; y++) {
for (int x = x0; x < x1; x++) {
boolean failed;
String reason;
int rgbref;
int rgbtst;
rgbtst = datatst[offtst+x] | opaque;
if (dataref == null) {
/* Outside of clip, must be white, no error tolerance */
rgbref = whitergb;
failed = (rgbtst != rgbref);
reason = "stray pixel rendered outside of clip";
} else {
/* Inside of clip, check for maxerr delta in components */
rgbref = dataref[offref+x] | opaque;
failed = (rgbref != rgbtst &&
maxdiff(rgbref, rgbtst) > maxerr);
reason = "different pixel rendered inside clip";
}
if (failed) {
if (dataref == null) {
numerrors++;
}
if (wasfill) {
numfillfailures++;
} else {
numstrokefailures++;
}
if (!silent) {
System.out.println("Failed: "+reason+" at "+x+", "+y+
" ["+Integer.toHexString(rgbref)+
" != "+Integer.toHexString(rgbtst)+
"]");
System.out.print(wasfill ? "Filled " : "Stroked ");
if (useAA) System.out.print("AA ");
if (strokePure) System.out.print("Pure ");
if (lw != 1) System.out.print("Lw="+lw+" ");
if (rot != 0) System.out.print("Rot="+rot+" ");
System.out.println(ar);
}
if (showErrors) {
show(imgref, imgtst);
}
return true;
}
}
offref += scanref;
offtst += scantst;
}
return false;
}
static ErrorWindow errw;
public static void show(BufferedImage imgref, BufferedImage imgtst) {
ErrorWindow errw = new ErrorWindow();
errw.setImages(imgref, imgtst);
errw.setVisible(true);
errw.waitForHide();
errw.dispose();
}
public static class Cubic extends AnnotatedShapeOp {
public static Cubic tryparse(String str) {
str = str.trim();
if (!str.startsWith("Cubic(")) {
return null;
}
str = str.substring(6);
double coords[] = new double[8];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index);
try {
coords[i] = Double.parseDouble(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
Cubic c = new Cubic();
c.cubic.setCurve(coords[0], coords[1],
coords[2], coords[3],
coords[4], coords[5],
coords[6], coords[7]);
return c;
}
private CubicCurve2D cubic = new CubicCurve2D.Double();
public void randomize() {
cubic.setCurve(randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord());
}
public Shape getShape() {
return cubic;
}
public String toString() {
return ("Cubic("+
cubic.getX1()+", "+
cubic.getY1()+", "+
cubic.getCtrlX1()+", "+
cubic.getCtrlY1()+", "+
cubic.getCtrlX2()+", "+
cubic.getCtrlY2()+", "+
cubic.getX2()+", "+
cubic.getY2()
+")");
}
}
public static class Quad extends AnnotatedShapeOp {
public static Quad tryparse(String str) {
str = str.trim();
if (!str.startsWith("Quad(")) {
return null;
}
str = str.substring(5);
double coords[] = new double[6];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index);
try {
coords[i] = Double.parseDouble(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
Quad c = new Quad();
c.quad.setCurve(coords[0], coords[1],
coords[2], coords[3],
coords[4], coords[5]);
return c;
}
private QuadCurve2D quad = new QuadCurve2D.Double();
public void randomize() {
quad.setCurve(randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord());
}
public Shape getShape() {
return quad;
}
public String toString() {
return ("Quad("+
quad.getX1()+", "+
quad.getY1()+", "+
quad.getCtrlX()+", "+
quad.getCtrlY()+", "+
quad.getX2()+", "+
quad.getY2()
+")");
}
}
public static class Poly extends AnnotatedShapeOp {
public static Poly tryparse(String str) {
str = str.trim();
if (!str.startsWith("Poly(")) {
return null;
}
str = str.substring(5);
Polygon p = new Polygon();
while (true) {
int x, y;
str = str.trim();
if (str.startsWith(")")) {
str = str.substring(1);
break;
}
if (p.npoints > 0) {
if (str.startsWith(",")) {
str = str.substring(2).trim();
} else {
return null;
}
}
if (str.startsWith("[")) {
str = str.substring(1);
} else {
return null;
}
int index = str.indexOf(",");
if (index < 0) {
return null;
}
String num = str.substring(0, index);
try {
x = Integer.parseInt(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
index = str.indexOf("]");
if (index < 0) {
return null;
}
num = str.substring(0, index).trim();
try {
y = Integer.parseInt(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
p.addPoint(x, y);
}
if (str.length() > 0) {
return null;
}
if (p.npoints < 3) {
return null;
}
return new Poly(p);
}
private Polygon poly;
public Poly() {
this.poly = new Polygon();
}
private Poly(Polygon p) {
this.poly = p;
}
public void randomize() {
poly.reset();
poly.addPoint(randIntCoord(), randIntCoord());
poly.addPoint(randIntCoord(), randIntCoord());
poly.addPoint(randIntCoord(), randIntCoord());
poly.addPoint(randIntCoord(), randIntCoord());
poly.addPoint(randIntCoord(), randIntCoord());
}
public Shape getShape() {
return poly;
}
public String toString() {
StringBuffer sb = new StringBuffer(100);
sb.append("Poly(");
for (int i = 0; i < poly.npoints; i++) {
if (i != 0) {
sb.append(", ");
}
sb.append("[");
sb.append(poly.xpoints[i]);
sb.append(", ");
sb.append(poly.ypoints[i]);
sb.append("]");
}
sb.append(")");
return sb.toString();
}
}
public static class Path extends AnnotatedShapeOp {
public static Path tryparse(String str) {
str = str.trim();
if (!str.startsWith("Path(")) {
return null;
}
str = str.substring(5);
GeneralPath gp = new GeneralPath();
float coords[] = new float[6];
int numsegs = 0;
while (true) {
int type;
int n;
str = str.trim();
if (str.startsWith(")")) {
str = str.substring(1);
break;
}
if (str.startsWith("M[")) {
type = PathIterator.SEG_MOVETO;
n = 2;
} else if (str.startsWith("L[")) {
type = PathIterator.SEG_LINETO;
n = 2;
} else if (str.startsWith("Q[")) {
type = PathIterator.SEG_QUADTO;
n = 4;
} else if (str.startsWith("C[")) {
type = PathIterator.SEG_CUBICTO;
n = 6;
} else if (str.startsWith("E[")) {
type = PathIterator.SEG_CLOSE;
n = 0;
} else {
return null;
}
str = str.substring(2);
if (n == 0) {
if (str.startsWith("]")) {
str = str.substring(1);
} else {
return null;
}
}
for (int i = 0; i < n; i++) {
int index;
if (i < n-1) {
index = str.indexOf(",");
} else {
index = str.indexOf("]");
}
if (index < 0) {
return null;
}
String num = str.substring(0, index);
try {
coords[i] = Float.parseFloat(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1).trim();
}
switch (type) {
case PathIterator.SEG_MOVETO:
gp.moveTo(coords[0], coords[1]);
break;
case PathIterator.SEG_LINETO:
gp.lineTo(coords[0], coords[1]);
break;
case PathIterator.SEG_QUADTO:
gp.quadTo(coords[0], coords[1],
coords[2], coords[3]);
break;
case PathIterator.SEG_CUBICTO:
gp.curveTo(coords[0], coords[1],
coords[2], coords[3],
coords[4], coords[5]);
break;
case PathIterator.SEG_CLOSE:
gp.closePath();
break;
}
numsegs++;
}
if (str.length() > 0) {
return null;
}
if (numsegs < 2) {
return null;
}
return new Path(gp);
}
private GeneralPath path;
public Path() {
this.path = new GeneralPath();
}
private Path(GeneralPath gp) {
this.path = gp;
}
public void randomize() {
path.reset();
path.moveTo(randFltCoord(), randFltCoord());
for (int i = randInt(5)+3; i > 0; --i) {
switch(randInt(5)) {
case 0:
path.moveTo(randFltCoord(), randFltCoord());
break;
case 1:
path.lineTo(randFltCoord(), randFltCoord());
break;
case 2:
path.quadTo(randFltCoord(), randFltCoord(),
randFltCoord(), randFltCoord());
break;
case 3:
path.curveTo(randFltCoord(), randFltCoord(),
randFltCoord(), randFltCoord(),
randFltCoord(), randFltCoord());
break;
case 4:
path.closePath();
break;
}
}
}
public Shape getShape() {
return path;
}
public String toString() {
StringBuffer sb = new StringBuffer(100);
sb.append("Path(");
PathIterator pi = path.getPathIterator(null);
float coords[] = new float[6];
boolean first = true;
while (!pi.isDone()) {
int n;
char c;
switch(pi.currentSegment(coords)) {
case PathIterator.SEG_MOVETO:
c = 'M';
n = 2;
break;
case PathIterator.SEG_LINETO:
c = 'L';
n = 2;
break;
case PathIterator.SEG_QUADTO:
c = 'Q';
n = 4;
break;
case PathIterator.SEG_CUBICTO:
c = 'C';
n = 6;
break;
case PathIterator.SEG_CLOSE:
c = 'E';
n = 0;
break;
default:
throw new InternalError("Unknown segment!");
}
sb.append(c);
sb.append("[");
for (int i = 0; i < n; i++) {
if (i != 0) {
sb.append(",");
}
sb.append(coords[i]);
}
sb.append("]");
pi.next();
}
sb.append(")");
return sb.toString();
}
}
public static class Rect extends AnnotatedShapeOp {
public static Rect tryparse(String str) {
str = str.trim();
if (!str.startsWith("Rect(")) {
return null;
}
str = str.substring(5);
double coords[] = new double[4];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index);
try {
coords[i] = Double.parseDouble(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
Rect r = new Rect();
r.rect.setRect(coords[0], coords[1],
coords[2], coords[3]);
return r;
}
private Rectangle2D rect = new Rectangle2D.Double();
public void randomize() {
rect.setRect(randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord());
}
public Shape getShape() {
return rect;
}
public String toString() {
return ("Rect("+
rect.getX()+", "+
rect.getY()+", "+
rect.getWidth()+", "+
rect.getHeight()
+")");
}
}
public static class Line extends AnnotatedShapeOp {
public static Line tryparse(String str) {
str = str.trim();
if (!str.startsWith("Line(")) {
return null;
}
str = str.substring(5);
double coords[] = new double[4];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index);
try {
coords[i] = Double.parseDouble(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
Line l = new Line();
l.line.setLine(coords[0], coords[1],
coords[2], coords[3]);
return l;
}
private Line2D line = new Line2D.Double();
public void randomize() {
line.setLine(randDblCoord(), randDblCoord(),
randDblCoord(), randDblCoord());
}
public Shape getShape() {
return line;
}
public String toString() {
return ("Line("+
line.getX1()+", "+
line.getY1()+", "+
line.getX2()+", "+
line.getY2()
+")");
}
}
public static class RectMethod extends AnnotatedRenderOp {
public static RectMethod tryparse(String str) {
str = str.trim();
if (!str.startsWith("RectMethod(")) {
return null;
}
str = str.substring(11);
int coords[] = new int[4];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index).trim();
try {
coords[i] = Integer.parseInt(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
RectMethod rm = new RectMethod();
rm.rect.setBounds(coords[0], coords[1],
coords[2], coords[3]);
return rm;
}
private Rectangle rect = new Rectangle();
public void randomize() {
rect.setBounds(randIntCoord(), randIntCoord(),
randIntCoord(), randIntCoord());
}
public void fill(Graphics2D g2d) {
g2d.fillRect(rect.x, rect.y, rect.width, rect.height);
}
public void draw(Graphics2D g2d) {
g2d.drawRect(rect.x, rect.y, rect.width, rect.height);
}
public String toString() {
return ("RectMethod("+
rect.x+", "+
rect.y+", "+
rect.width+", "+
rect.height
+")");
}
}
public static class LineMethod extends AnnotatedRenderOp {
public static LineMethod tryparse(String str) {
str = str.trim();
if (!str.startsWith("LineMethod(")) {
return null;
}
str = str.substring(11);
int coords[] = new int[4];
boolean foundparen = false;
for (int i = 0; i < coords.length; i++) {
int index = str.indexOf(",");
if (index < 0) {
if (i < coords.length-1) {
return null;
}
index = str.indexOf(")");
if (index < 0) {
return null;
}
foundparen = true;
}
String num = str.substring(0, index).trim();
try {
coords[i] = Integer.parseInt(num);
} catch (NumberFormatException nfe) {
return null;
}
str = str.substring(index+1);
}
if (!foundparen || str.length() > 0) {
return null;
}
LineMethod lm = new LineMethod();
lm.line = coords;
return lm;
}
private int line[] = new int[4];
public void randomize() {
line[0] = randIntCoord();
line[1] = randIntCoord();
line[2] = randIntCoord();
line[3] = randIntCoord();
}
public void fill(Graphics2D g2d) {
}
public void draw(Graphics2D g2d) {
g2d.drawLine(line[0], line[1], line[2], line[3]);
}
public String toString() {
return ("LineMethod("+
line[0]+", "+
line[1]+", "+
line[2]+", "+
line[3]
+")");
}
}
public static class ErrorWindow extends Frame {
ImageCanvas unclipped;
ImageCanvas reference;
ImageCanvas actual;
ImageCanvas diff;
public ErrorWindow() {
super("Error Comparison Window");
unclipped = new ImageCanvas();
reference = new ImageCanvas();
actual = new ImageCanvas();
diff = new ImageCanvas();
setLayout(new SmartGridLayout(0, 2, 5, 5));
addImagePanel(unclipped, "Unclipped rendering");
addImagePanel(reference, "Clipped reference");
addImagePanel(actual, "Actual clipped");
addImagePanel(diff, "Difference");
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
setVisible(false);
}
});
}
public void addImagePanel(ImageCanvas ic, String label) {
add(ic);
add(new Label(label));
}
public void setImages(BufferedImage imgref, BufferedImage imgtst) {
unclipped.setImage(imgref);
reference.setReference(imgref);
actual.setImage(imgtst);
diff.setDiff(reference.getImage(), imgtst);
invalidate();
pack();
repaint();
}
public void setVisible(boolean vis) {
super.setVisible(vis);
synchronized (this) {
notifyAll();
}
}
public synchronized void waitForHide() {
while (isShowing()) {
try {
wait();
} catch (InterruptedException e) {
System.exit(2);
}
}
}
}
public static class SmartGridLayout implements LayoutManager {
int rows;
int cols;
int hgap;
int vgap;
public SmartGridLayout(int r, int c, int h, int v) {
this.rows = r;
this.cols = c;
this.hgap = h;
this.vgap = v;
}
public void addLayoutComponent(String name, Component comp) {
}
public void removeLayoutComponent(Component comp) {
}
public int[][] getGridSizes(Container parent, boolean min) {
int ncomponents = parent.getComponentCount();
int nrows = rows;
int ncols = cols;
if (nrows > 0) {
ncols = (ncomponents + nrows - 1) / nrows;
} else {
nrows = (ncomponents + ncols - 1) / ncols;
}
int widths[] = new int[ncols+1];
int heights[] = new int[nrows+1];
int x = 0;
int y = 0;
for (int i = 0 ; i < ncomponents ; i++) {
Component comp = parent.getComponent(i);
Dimension d = (min
? comp.getMinimumSize()
: comp.getPreferredSize());
if (widths[x] < d.width) {
widths[x] = d.width;
}
if (heights[y] < d.height) {
heights[y] = d.height;
}
x++;
if (x >= ncols) {
x = 0;
y++;
}
}
for (int i = 0; i < ncols; i++) {
widths[ncols] += widths[i];
}
for (int i = 0; i < nrows; i++) {
heights[nrows] += heights[i];
}
return new int[][] { widths, heights };
}
public Dimension getSize(Container parent, boolean min) {
int sizes[][] = getGridSizes(parent, min);
int widths[] = sizes[0];
int heights[] = sizes[1];
int nrows = heights.length-1;
int ncols = widths.length-1;
int w = widths[ncols];
int h = heights[nrows];
Insets insets = parent.getInsets();
return new Dimension(insets.left+insets.right + w+(ncols+1)*hgap,
insets.top+insets.bottom + h+(nrows+1)*vgap);
}
public Dimension preferredLayoutSize(Container parent) {
return getSize(parent, false);
}
public Dimension minimumLayoutSize(Container parent) {
return getSize(parent, true);
}
public void layoutContainer(Container parent) {
int pref[][] = getGridSizes(parent, false);
int min[][] = getGridSizes(parent, true);
int minwidths[] = min[0];
int minheights[] = min[1];
int prefwidths[] = pref[0];
int prefheights[] = pref[1];
int nrows = minheights.length - 1;
int ncols = minwidths.length - 1;
Insets insets = parent.getInsets();
int w = parent.getWidth() - insets.left - insets.right;
int h = parent.getHeight() - insets.top - insets.bottom;
w = w - (ncols+1)*hgap;
h = h - (nrows+1)*vgap;
int widths[] = calculateSizes(w, ncols, minwidths, prefwidths);
int heights[] = calculateSizes(h, nrows, minheights, prefheights);
int ncomponents = parent.getComponentCount();
int x = insets.left + hgap;
int y = insets.top + vgap;
int r = 0;
int c = 0;
for (int i = 0; i < ncomponents; i++) {
parent.getComponent(i).setBounds(x, y, widths[c], heights[r]);
x += widths[c++] + hgap;
if (c >= ncols) {
c = 0;
x = insets.left + hgap;
y += heights[r++] + vgap;
if (r >= nrows) {
// just in case
break;
}
}
}
}
public static int[] calculateSizes(int total, int num,
int minsizes[], int prefsizes[])
{
if (total <= minsizes[num]) {
return minsizes;
}
if (total >= prefsizes[num]) {
return prefsizes;
}
int sizes[] = new int[total];
int prevhappy = 0;
int nhappy = 0;
int happysize = 0;
do {
int addsize = (total - happysize) / (num - nhappy);
happysize = 0;
for (int i = 0; i < num; i++) {
if (sizes[i] >= prefsizes[i] ||
minsizes[i] + addsize > prefsizes[i])
{
happysize += (sizes[i] = prefsizes[i]);
nhappy++;
} else {
sizes[i] = minsizes[i] + addsize;
}
}
} while (nhappy < num && nhappy > prevhappy);
return sizes;
}
}
public static class ImageCanvas extends Canvas {
BufferedImage image;
public void setImage(BufferedImage img) {
this.image = img;
}
public BufferedImage getImage() {
return image;
}
public void checkImage(int w, int h) {
if (image == null ||
image.getWidth() < w ||
image.getHeight() < h)
{
image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
}
}
public void setReference(BufferedImage img) {
checkImage(img.getWidth(), img.getHeight());
Graphics g = image.createGraphics();
g.drawImage(img, 0, 0, null);
g.setColor(Color.white);
g.fillRect(0, 0, 30, 10);
g.fillRect(30, 0, 10, 30);
g.fillRect(10, 30, 30, 10);
g.fillRect(0, 10, 10, 30);
g.dispose();
}
public void setDiff(BufferedImage imgref, BufferedImage imgtst) {
int w = Math.max(imgref.getWidth(), imgtst.getWidth());
int h = Math.max(imgref.getHeight(), imgtst.getHeight());
checkImage(w, h);
Graphics g = image.createGraphics();
g.drawImage(imgref, 0, 0, null);
g.setXORMode(Color.white);
g.drawImage(imgtst, 0, 0, null);
g.setPaintMode();
g.setColor(new Color(1f, 1f, 0f, 0.25f));
g.fillRect(10, 10, 20, 20);
g.setColor(new Color(1f, 0f, 0f, 0.25f));
g.fillRect(0, 0, 30, 10);
g.fillRect(30, 0, 10, 30);
g.fillRect(10, 30, 30, 10);
g.fillRect(0, 10, 10, 30);
g.dispose();
}
public Dimension getPreferredSize() {
if (image == null) {
return new Dimension();
} else {
return new Dimension(image.getWidth(), image.getHeight());
}
}
public void paint(Graphics g) {
g.drawImage(image, 0, 0, null);
}
}
}