1635 lines
55 KiB
Java
1635 lines
55 KiB
Java
/*
|
|
* 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);
|
|
}
|
|
}
|
|
}
|