8228711: Path rendered incorrectly when it goes outside the clipping region
Summary: fixed closePath() to preserve last position and its outcode in Stroker and TransformingPathConsumer2D.PathClipFilter
Reviewed-by: prr, kcr
/*
* Copyright (c) 2017, 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.
*/
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.Shape;
import java.awt.geom.CubicCurve2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Path2D;
import java.awt.geom.PathIterator;
import java.awt.geom.QuadCurve2D;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Locale;
import java.util.Random;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.logging.Handler;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;
/**
* @test
* @bug 8191814
* @summary Verifies that Marlin rendering generates the same
* images with and without clipping optimization with all possible
* stroke (cap/join) and/or dashes or fill modes (EO rules)
* for paths made of either 9 lines, 4 quads, 2 cubics (random)
* Note: Use the argument -slow to run more intensive tests (too much time)
*
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.MarlinRenderingEngine ClipShapeTest -poly
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.MarlinRenderingEngine ClipShapeTest -poly -doDash
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.MarlinRenderingEngine ClipShapeTest -cubic
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.MarlinRenderingEngine ClipShapeTest -cubic -doDash
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.DMarlinRenderingEngine ClipShapeTest -poly
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.DMarlinRenderingEngine ClipShapeTest -poly -doDash
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.DMarlinRenderingEngine ClipShapeTest -cubic
* @run main/othervm/timeout=300 -Dsun.java2d.renderer=sun.java2d.marlin.DMarlinRenderingEngine ClipShapeTest -cubic -doDash
*/
public final class ClipShapeTest {
// test options:
static int NUM_TESTS;
// shape settings:
static ShapeMode SHAPE_MODE;
static boolean USE_DASHES;
static boolean USE_VAR_STROKE;
static int THRESHOLD_DELTA;
static long THRESHOLD_NBPIX;
// constants:
static final boolean DO_FAIL = Boolean.valueOf(System.getProperty("ClipShapeTest.fail", "true"));
static final boolean TEST_STROKER = true;
static final boolean TEST_FILLER = true;
static final boolean SUBDIVIDE_CURVE = true;
static final double SUBDIVIDE_LEN_TH = 50.0;
static final boolean TRACE_SUBDIVIDE_CURVE = false;
static final int TESTW = 100;
static final int TESTH = 100;
// dump path on console:
static final boolean DUMP_SHAPE = true;
static final boolean SHOW_DETAILS = false; // disabled
static final boolean SHOW_OUTLINE = true;
static final boolean SHOW_POINTS = true;
static final boolean SHOW_INFO = false;
static final int MAX_SHOW_FRAMES = 10;
static final int MAX_SAVE_FRAMES = 100;
// use fixed seed to reproduce always same polygons between tests
static final boolean FIXED_SEED = true;
static final double RAND_SCALE = 3.0;
static final double RANDW = TESTW * RAND_SCALE;
static final double OFFW = (TESTW - RANDW) / 2.0;
static final double RANDH = TESTH * RAND_SCALE;
static final double OFFH = (TESTH - RANDH) / 2.0;
static enum ShapeMode {
TWO_CUBICS,
FOUR_QUADS,
FIVE_LINE_POLYS,
NINE_LINE_POLYS,
FIFTY_LINE_POLYS,
MIXED
}
static final long SEED = 1666133789L;
// Fixed seed to avoid any difference between runs:
static final Random RANDOM = new Random(SEED);
static final File OUTPUT_DIR = new File(".");
static final AtomicBoolean isMarlin = new AtomicBoolean();
static final AtomicBoolean isMarlinFloat = new AtomicBoolean();
static final AtomicBoolean isClipRuntime = new AtomicBoolean();
static {
Locale.setDefault(Locale.US);
// FIRST: Get Marlin runtime state from its log:
// initialize j.u.l Looger:
final Logger log = Logger.getLogger("sun.java2d.marlin");
log.addHandler(new Handler() {
@Override
public void publish(LogRecord record) {
final String msg = record.getMessage();
if (msg != null) {
// last space to avoid matching other settings:
if (msg.startsWith("sun.java2d.renderer ")) {
isMarlin.set(msg.contains("MarlinRenderingEngine"));
isMarlinFloat.set(!msg.contains("DMarlinRenderingEngine"));
}
if (msg.startsWith("sun.java2d.renderer.clip.runtime.enable")) {
isClipRuntime.set(msg.contains("true"));
}
}
final Throwable th = record.getThrown();
// detect any Throwable:
if (th != null) {
System.out.println("Test failed:\n" + record.getMessage());
th.printStackTrace(System.out);
throw new RuntimeException("Test failed: ", th);
}
}
@Override
public void flush() {
}
@Override
public void close() throws SecurityException {
}
});
// enable Marlin logging & internal checks:
System.setProperty("sun.java2d.renderer.log", "true");
System.setProperty("sun.java2d.renderer.useLogger", "true");
// disable static clipping setting:
System.setProperty("sun.java2d.renderer.clip", "false");
System.setProperty("sun.java2d.renderer.clip.runtime.enable", "true");
// enable subdivider:
System.setProperty("sun.java2d.renderer.clip.subdivider", "true");
// disable min length check: always subdivide curves at clip edges
System.setProperty("sun.java2d.renderer.clip.subdivider.minLength", "-1");
// If any curve, increase curve accuracy:
// curve length max error:
System.setProperty("sun.java2d.renderer.curve_len_err", "1e-4");
// cubic min/max error:
System.setProperty("sun.java2d.renderer.cubic_dec_d2", "1e-3");
System.setProperty("sun.java2d.renderer.cubic_inc_d1", "1e-4");
// quad max error:
System.setProperty("sun.java2d.renderer.quad_dec_d2", "5e-4");
}
private static void resetOptions() {
NUM_TESTS = Integer.getInteger("ClipShapeTest.numTests", 5000);
// shape settings:
SHAPE_MODE = ShapeMode.NINE_LINE_POLYS;
USE_DASHES = false;
USE_VAR_STROKE = false;
}
/**
* Test
* @param args
*/
public static void main(String[] args) {
{
// Bootstrap: init Renderer now:
final BufferedImage img = newImage(TESTW, TESTH);
final Graphics2D g2d = initialize(img, null);
try {
paintShape(new Line2D.Double(0,0,100,100), g2d, true, false);
} finally {
g2d.dispose();
}
if (!isMarlin.get()) {
throw new RuntimeException("Marlin renderer not used at runtime !");
}
if (!isClipRuntime.get()) {
throw new RuntimeException("Marlin clipping not enabled at runtime !");
}
}
System.out.println("---------------------------------------");
System.out.println("ClipShapeTest: image = " + TESTW + " x " + TESTH);
resetOptions();
boolean runSlowTests = false;
for (String arg : args) {
if ("-slow".equals(arg)) {
runSlowTests = true;
} else if ("-doDash".equals(arg)) {
USE_DASHES = true;
} else if ("-doVarStroke".equals(arg)) {
USE_VAR_STROKE = true;
} else {
// shape mode:
if (arg.equalsIgnoreCase("-poly")) {
SHAPE_MODE = ShapeMode.NINE_LINE_POLYS;
} else if (arg.equalsIgnoreCase("-bigpoly")) {
SHAPE_MODE = ShapeMode.FIFTY_LINE_POLYS;
} else if (arg.equalsIgnoreCase("-quad")) {
SHAPE_MODE = ShapeMode.FOUR_QUADS;
} else if (arg.equalsIgnoreCase("-cubic")) {
SHAPE_MODE = ShapeMode.TWO_CUBICS;
} else if (arg.equalsIgnoreCase("-mixed")) {
SHAPE_MODE = ShapeMode.MIXED;
}
}
}
System.out.println("Shape mode: " + SHAPE_MODE);
// adjust image comparison thresholds:
switch (SHAPE_MODE) {
case TWO_CUBICS:
// Define uncertainty for curves:
THRESHOLD_DELTA = 32;
THRESHOLD_NBPIX = (USE_DASHES) ? 50 : 200;
if (SUBDIVIDE_CURVE) {
THRESHOLD_NBPIX = 4;
}
break;
case FOUR_QUADS:
case MIXED:
// Define uncertainty for quads:
// curve subdivision causes curves to be smaller
// then curve offsets are different (more accurate)
THRESHOLD_DELTA = 64;
THRESHOLD_NBPIX = (USE_DASHES) ? 40 : 420;
if (SUBDIVIDE_CURVE) {
THRESHOLD_NBPIX = 10;
}
break;
default:
// Define uncertainty for lines:
// float variant have higher uncertainty
THRESHOLD_DELTA = 2;
THRESHOLD_NBPIX = (USE_DASHES) ?
// float variant have higher uncertainty
((isMarlinFloat.get()) ? 30 : 6) // low for double
: (isMarlinFloat.get()) ? 10 : 0;
}
// Visual inspection (low threshold):
// THRESHOLD_NBPIX = 2;
System.out.println("THRESHOLD_DELTA: " + THRESHOLD_DELTA);
System.out.println("THRESHOLD_NBPIX: " + THRESHOLD_NBPIX);
if (runSlowTests) {
NUM_TESTS = 10000; // or 100000 (very slow)
USE_VAR_STROKE = true;
}
System.out.println("NUM_TESTS: " + NUM_TESTS);
if (USE_DASHES) {
System.out.println("USE_DASHES: enabled.");
}
if (USE_VAR_STROKE) {
System.out.println("USE_VAR_STROKE: enabled.");
}
if (!DO_FAIL) {
System.out.println("DO_FAIL: disabled.");
}
System.out.println("---------------------------------------");
final DiffContext allCtx = new DiffContext("All Test setups");
final DiffContext allWorstCtx = new DiffContext("Worst(All Test setups)");
int failures = 0;
final long start = System.nanoTime();
try {
if (TEST_STROKER) {
final float[][] dashArrays = (USE_DASHES) ?
// small
// new float[][]{new float[]{1f, 2f}}
// normal
new float[][]{new float[]{13f, 7f}}
// large (prime)
// new float[][]{new float[]{41f, 7f}}
// none
: new float[][]{null};
System.out.println("dashes: " + Arrays.deepToString(dashArrays));
final float[] strokeWidths = (USE_VAR_STROKE)
? new float[5] :
new float[]{10f};
int nsw = 0;
if (USE_VAR_STROKE) {
for (float width = 0.25f; width < 110f; width *= 5f) {
strokeWidths[nsw++] = width;
}
} else {
nsw = 1;
}
System.out.println("stroke widths: " + Arrays.toString(strokeWidths));
// Stroker tests:
for (int w = 0; w < nsw; w++) {
final float width = strokeWidths[w];
for (float[] dashes : dashArrays) {
for (int cap = 0; cap <= 2; cap++) {
for (int join = 0; join <= 2; join++) {
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, false, width, cap, join, dashes));
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, true, width, cap, join, dashes));
}
}
}
}
}
if (TEST_FILLER) {
// Filler tests:
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, false, Path2D.WIND_NON_ZERO));
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, true, Path2D.WIND_NON_ZERO));
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, false, Path2D.WIND_EVEN_ODD));
failures += paintPaths(allCtx, allWorstCtx, new TestSetup(SHAPE_MODE, true, Path2D.WIND_EVEN_ODD));
}
} catch (IOException ioe) {
throw new RuntimeException(ioe);
}
System.out.println("main: duration= " + (1e-6 * (System.nanoTime() - start)) + " ms.");
allWorstCtx.dump();
allCtx.dump();
if (DO_FAIL && (failures != 0)) {
throw new RuntimeException("Clip test failures : " + failures);
}
}
static int paintPaths(final DiffContext allCtx, final DiffContext allWorstCtx, final TestSetup ts) throws IOException {
final long start = System.nanoTime();
if (FIXED_SEED) {
// Reset seed for random numbers:
RANDOM.setSeed(SEED);
}
System.out.println("paintPaths: " + NUM_TESTS
+ " paths (" + SHAPE_MODE + ") - setup: " + ts);
final boolean fill = !ts.isStroke();
final Path2D p2d = new Path2D.Double(ts.windingRule);
final Stroke stroke = (!fill) ? createStroke(ts) : null;
final BufferedImage imgOn = newImage(TESTW, TESTH);
final Graphics2D g2dOn = initialize(imgOn, stroke);
final BufferedImage imgOff = newImage(TESTW, TESTH);
final Graphics2D g2dOff = initialize(imgOff, stroke);
final BufferedImage imgDiff = newImage(TESTW, TESTH);
final DiffContext testSetupCtx = new DiffContext("Test setup");
final DiffContext testWorstCtx = new DiffContext("Worst");
final DiffContext testWorstThCtx = new DiffContext("Worst(>threshold)");
int nd = 0;
try {
final DiffContext testCtx = new DiffContext("Test");
final DiffContext testThCtx = new DiffContext("Test(>threshold)");
BufferedImage diffImage;
for (int n = 0; n < NUM_TESTS; n++) {
genShape(p2d, ts);
// Runtime clip setting OFF:
paintShape(p2d, g2dOff, fill, false);
// Runtime clip setting ON:
paintShape(p2d, g2dOn, fill, true);
/* compute image difference if possible */
diffImage = computeDiffImage(testCtx, testThCtx, imgOn, imgOff, imgDiff);
// Worst (total)
if (testCtx.isDiff()) {
if (testWorstCtx.isWorse(testCtx, false)) {
testWorstCtx.set(testCtx);
}
if (testWorstThCtx.isWorse(testCtx, true)) {
testWorstThCtx.set(testCtx);
}
// accumulate data:
testSetupCtx.add(testCtx);
}
if (diffImage != null) {
nd++;
testThCtx.dump();
testCtx.dump();
if (nd < MAX_SHOW_FRAMES) {
if (SHOW_DETAILS) {
paintShapeDetails(g2dOff, p2d);
paintShapeDetails(g2dOn, p2d);
}
if (nd < MAX_SAVE_FRAMES) {
if (DUMP_SHAPE) {
dumpShape(p2d);
}
final String testName = "Setup_" + ts.id + "_test_" + n;
saveImage(imgOff, OUTPUT_DIR, testName + "-off.png");
saveImage(imgOn, OUTPUT_DIR, testName + "-on.png");
saveImage(imgDiff, OUTPUT_DIR, testName + "-diff.png");
}
}
}
}
} finally {
g2dOff.dispose();
g2dOn.dispose();
if (nd != 0) {
System.out.println("paintPaths: " + NUM_TESTS + " paths - "
+ "Number of differences = " + nd
+ " ratio = " + (100f * nd) / NUM_TESTS + " %");
}
if (testWorstCtx.isDiff()) {
testWorstCtx.dump();
if (testWorstThCtx.isDiff() && testWorstThCtx.histPix.sum != testWorstCtx.histPix.sum) {
testWorstThCtx.dump();
}
if (allWorstCtx.isWorse(testWorstThCtx, true)) {
allWorstCtx.set(testWorstThCtx);
}
}
testSetupCtx.dump();
// accumulate data:
allCtx.add(testSetupCtx);
}
System.out.println("paintPaths: duration= " + (1e-6 * (System.nanoTime() - start)) + " ms.");
return nd;
}
private static void paintShape(final Shape p2d, final Graphics2D g2d,
final boolean fill, final boolean clip) {
reset(g2d);
setClip(g2d, clip);
if (fill) {
g2d.fill(p2d);
} else {
g2d.draw(p2d);
}
}
private static Graphics2D initialize(final BufferedImage img,
final Stroke s) {
final Graphics2D g2d = (Graphics2D) img.getGraphics();
g2d.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g2d.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
// Test normalize:
// RenderingHints.VALUE_STROKE_NORMALIZE
RenderingHints.VALUE_STROKE_PURE
);
if (s != null) {
g2d.setStroke(s);
}
g2d.setColor(Color.BLACK);
return g2d;
}
private static void reset(final Graphics2D g2d) {
// Disable antialiasing:
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_OFF);
g2d.setBackground(Color.WHITE);
g2d.clearRect(0, 0, TESTW, TESTH);
}
private static void setClip(final Graphics2D g2d, final boolean clip) {
// Enable antialiasing:
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
// Enable or Disable clipping:
System.setProperty("sun.java2d.renderer.clip.runtime", (clip) ? "true" : "false");
}
static void genShape(final Path2D p2d, final TestSetup ts) {
p2d.reset();
/*
Test closed path:
0: moveTo + (draw)To + closePath
1: (draw)To + closePath (closePath + (draw)To sequence)
*/
final int end = (ts.closed) ? 2 : 1;
final double[] in = new double[8];
double sx0 = 0.0, sy0 = 0.0, x0 = 0.0, y0 = 0.0;
for (int p = 0; p < end; p++) {
if (p <= 0) {
x0 = randX(); y0 = randY();
p2d.moveTo(x0, y0);
sx0 = x0; sy0 = y0;
}
switch (ts.shapeMode) {
case MIXED:
case FIVE_LINE_POLYS:
case NINE_LINE_POLYS:
case FIFTY_LINE_POLYS:
p2d.lineTo(randX(), randY());
p2d.lineTo(randX(), randY());
p2d.lineTo(randX(), randY());
p2d.lineTo(randX(), randY());
x0 = randX(); y0 = randY();
p2d.lineTo(x0, y0);
if (ts.shapeMode == ShapeMode.FIVE_LINE_POLYS) {
// And an implicit close makes 5 lines
break;
}
p2d.lineTo(randX(), randY());
p2d.lineTo(randX(), randY());
p2d.lineTo(randX(), randY());
x0 = randX(); y0 = randY();
p2d.lineTo(x0, y0);
if (ts.shapeMode == ShapeMode.NINE_LINE_POLYS) {
// And an implicit close makes 9 lines
break;
}
if (ts.shapeMode == ShapeMode.FIFTY_LINE_POLYS) {
for (int i = 0; i < 41; i++) {
x0 = randX(); y0 = randY();
p2d.lineTo(x0, y0);
}
// And an implicit close makes 50 lines
break;
}
case TWO_CUBICS:
if (SUBDIVIDE_CURVE) {
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
in[4] = randX(); in[5] = randY();
x0 = randX(); y0 = randY();
in[6] = x0; in[7] = y0;
subdivide(p2d, 8, in);
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
in[4] = randX(); in[5] = randY();
x0 = randX(); y0 = randY();
in[6] = x0; in[7] = y0;
subdivide(p2d, 8, in);
} else {
x0 = randX(); y0 = randY();
p2d.curveTo(randX(), randY(), randX(), randY(), x0, y0);
x0 = randX(); y0 = randY();
p2d.curveTo(randX(), randY(), randX(), randY(), x0, y0);
}
if (ts.shapeMode == ShapeMode.TWO_CUBICS) {
break;
}
case FOUR_QUADS:
if (SUBDIVIDE_CURVE) {
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
x0 = randX(); y0 = randY();
in[4] = x0; in[5] = y0;
subdivide(p2d, 6, in);
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
x0 = randX(); y0 = randY();
in[4] = x0; in[5] = y0;
subdivide(p2d, 6, in);
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
x0 = randX(); y0 = randY();
in[4] = x0; in[5] = y0;
subdivide(p2d, 6, in);
in[0] = x0; in[1] = y0;
in[2] = randX(); in[3] = randY();
x0 = randX(); y0 = randY();
in[4] = x0; in[5] = y0;
subdivide(p2d, 6, in);
} else {
x0 = randX(); y0 = randY();
p2d.quadTo(randX(), randY(), x0, y0);
x0 = randX(); y0 = randY();
p2d.quadTo(randX(), randY(), x0, y0);
x0 = randX(); y0 = randY();
p2d.quadTo(randX(), randY(), x0, y0);
x0 = randX(); y0 = randY();
p2d.quadTo(randX(), randY(), x0, y0);
}
if (ts.shapeMode == ShapeMode.FOUR_QUADS) {
break;
}
default:
}
if (ts.closed) {
p2d.closePath();
x0 = sx0; y0 = sy0;
}
}
}
static final int SUBDIVIDE_LIMIT = 5;
static final double[][] SUBDIVIDE_CURVES = new double[SUBDIVIDE_LIMIT + 1][];
static {
for (int i = 0, n = 1; i < SUBDIVIDE_LIMIT; i++, n *= 2) {
SUBDIVIDE_CURVES[i] = new double[8 * n];
}
}
static void subdivide(final Path2D p2d, final int type, final double[] in) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("subdivide: " + Arrays.toString(Arrays.copyOf(in, type)));
}
double curveLen = ((type == 8)
? curvelen(in[0], in[1], in[2], in[3], in[4], in[5], in[6], in[7])
: quadlen(in[0], in[1], in[2], in[3], in[4], in[5]));
if (curveLen > SUBDIVIDE_LEN_TH) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("curvelen: " + curveLen);
}
System.arraycopy(in, 0, SUBDIVIDE_CURVES[0], 0, 8);
int level = 0;
while (curveLen >= SUBDIVIDE_LEN_TH) {
level++;
curveLen /= 2.0;
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("curvelen: " + curveLen);
}
}
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("level: " + level);
}
if (level > SUBDIVIDE_LIMIT) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("max level reached : " + level);
}
level = SUBDIVIDE_LIMIT;
}
for (int l = 0; l < level; l++) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("level: " + l);
}
double[] src = SUBDIVIDE_CURVES[l];
double[] dst = SUBDIVIDE_CURVES[l + 1];
for (int i = 0, j = 0; i < src.length; i += 8, j += 16) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("subdivide: " + Arrays.toString(Arrays.copyOfRange(src, i, i + type)));
}
if (type == 8) {
CubicCurve2D.subdivide(src, i, dst, j, dst, j + 8);
} else {
QuadCurve2D.subdivide(src, i, dst, j, dst, j + 8);
}
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("left: " + Arrays.toString(Arrays.copyOfRange(dst, j, j + type)));
System.out.println("right: " + Arrays.toString(Arrays.copyOfRange(dst, j + 8, j + 8 + type)));
}
}
}
// Emit curves at last level:
double[] src = SUBDIVIDE_CURVES[level];
double len = 0.0;
for (int i = 0; i < src.length; i += 8) {
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("curve: " + Arrays.toString(Arrays.copyOfRange(src, i, i + type)));
}
if (type == 8) {
if (TRACE_SUBDIVIDE_CURVE) {
len += curvelen(src[i + 0], src[i + 1], src[i + 2], src[i + 3], src[i + 4], src[i + 5], src[i + 6], src[i + 7]);
}
p2d.curveTo(src[i + 2], src[i + 3], src[i + 4], src[i + 5], src[i + 6], src[i + 7]);
} else {
if (TRACE_SUBDIVIDE_CURVE) {
len += quadlen(src[i + 0], src[i + 1], src[i + 2], src[i + 3], src[i + 4], src[i + 5]);
}
p2d.quadTo(src[i + 2], src[i + 3], src[i + 4], src[i + 5]);
}
}
if (TRACE_SUBDIVIDE_CURVE) {
System.out.println("curveLen (final) = " + len);
}
} else {
if (type == 8) {
p2d.curveTo(in[2], in[3], in[4], in[5], in[6], in[7]);
} else {
p2d.quadTo(in[2], in[3], in[4], in[5]);
}
}
}
static final float POINT_RADIUS = 2f;
static final float LINE_WIDTH = 1f;
static final Stroke OUTLINE_STROKE = new BasicStroke(LINE_WIDTH);
static final int COLOR_ALPHA = 128;
static final Color COLOR_MOVETO = new Color(255, 0, 0, COLOR_ALPHA);
static final Color COLOR_LINETO_ODD = new Color(0, 0, 255, COLOR_ALPHA);
static final Color COLOR_LINETO_EVEN = new Color(0, 255, 0, COLOR_ALPHA);
static final Ellipse2D.Float ELL_POINT = new Ellipse2D.Float();
private static void paintShapeDetails(final Graphics2D g2d, final Shape shape) {
final Stroke oldStroke = g2d.getStroke();
final Color oldColor = g2d.getColor();
setClip(g2d, false);
if (SHOW_OUTLINE) {
g2d.setStroke(OUTLINE_STROKE);
g2d.setColor(COLOR_LINETO_ODD);
g2d.draw(shape);
}
final float[] coords = new float[6];
float px, py;
int nMove = 0;
int nLine = 0;
int n = 0;
for (final PathIterator it = shape.getPathIterator(null); !it.isDone(); it.next()) {
int type = it.currentSegment(coords);
switch (type) {
case PathIterator.SEG_MOVETO:
if (SHOW_POINTS) {
g2d.setColor(COLOR_MOVETO);
}
break;
case PathIterator.SEG_LINETO:
case PathIterator.SEG_QUADTO:
case PathIterator.SEG_CUBICTO:
if (SHOW_POINTS) {
g2d.setColor((nLine % 2 == 0) ? COLOR_LINETO_ODD : COLOR_LINETO_EVEN);
}
nLine++;
break;
case PathIterator.SEG_CLOSE:
continue;
default:
System.out.println("unsupported segment type= " + type);
continue;
}
px = coords[0];
py = coords[1];
if (SHOW_INFO) {
System.out.println("point[" + (n++) + "|seg=" + type + "]: " + px + " " + py);
}
if (SHOW_POINTS) {
ELL_POINT.setFrame(px - POINT_RADIUS, py - POINT_RADIUS,
POINT_RADIUS * 2f, POINT_RADIUS * 2f);
g2d.fill(ELL_POINT);
}
}
if (SHOW_INFO) {
System.out.println("Path moveTo=" + nMove + ", lineTo=" + nLine);
System.out.println("--------------------------------------------------");
}
g2d.setStroke(oldStroke);
g2d.setColor(oldColor);
}
private static void dumpShape(final Shape shape) {
final float[] coords = new float[6];
for (final PathIterator it = shape.getPathIterator(null); !it.isDone(); it.next()) {
final int type = it.currentSegment(coords);
switch (type) {
case PathIterator.SEG_MOVETO:
System.out.println("p2d.moveTo(" + coords[0] + ", " + coords[1] + ");");
break;
case PathIterator.SEG_LINETO:
System.out.println("p2d.lineTo(" + coords[0] + ", " + coords[1] + ");");
break;
case PathIterator.SEG_QUADTO:
System.out.println("p2d.quadTo(" + coords[0] + ", " + coords[1] + ", " + coords[2] + ", " + coords[3] + ");");
break;
case PathIterator.SEG_CUBICTO:
System.out.println("p2d.curveTo(" + coords[0] + ", " + coords[1] + ", " + coords[2] + ", " + coords[3] + ", " + coords[4] + ", " + coords[5] + ");");
break;
case PathIterator.SEG_CLOSE:
System.out.println("p2d.closePath();");
break;
default:
System.out.println("// Unsupported segment type= " + type);
}
}
System.out.println("--------------------------------------------------");
}
static double randX() {
return RANDOM.nextDouble() * RANDW + OFFW;
}
static double randY() {
return RANDOM.nextDouble() * RANDH + OFFH;
}
private static BasicStroke createStroke(final TestSetup ts) {
return new BasicStroke(ts.strokeWidth, ts.strokeCap, ts.strokeJoin, 10.0f, ts.dashes, 0.0f);
}
private final static class TestSetup {
static final AtomicInteger COUNT = new AtomicInteger();
final int id;
final ShapeMode shapeMode;
final boolean closed;
// stroke
final float strokeWidth;
final int strokeCap;
final int strokeJoin;
final float[] dashes;
// fill
final int windingRule;
TestSetup(ShapeMode shapeMode, final boolean closed,
final float strokeWidth, final int strokeCap, final int strokeJoin, final float[] dashes) {
this.id = COUNT.incrementAndGet();
this.shapeMode = shapeMode;
this.closed = closed;
this.strokeWidth = strokeWidth;
this.strokeCap = strokeCap;
this.strokeJoin = strokeJoin;
this.dashes = dashes;
this.windingRule = Path2D.WIND_NON_ZERO;
}
TestSetup(ShapeMode shapeMode, final boolean closed, final int windingRule) {
this.id = COUNT.incrementAndGet();
this.shapeMode = shapeMode;
this.closed = closed;
this.strokeWidth = 0f;
this.strokeCap = this.strokeJoin = -1; // invalid
this.dashes = null;
this.windingRule = windingRule;
}
boolean isStroke() {
return this.strokeWidth > 0f;
}
@Override
public String toString() {
if (isStroke()) {
return "TestSetup{id=" + id + ", shapeMode=" + shapeMode + ", closed=" + closed
+ ", strokeWidth=" + strokeWidth + ", strokeCap=" + getCap(strokeCap) + ", strokeJoin=" + getJoin(strokeJoin)
+ ((dashes != null) ? ", dashes: " + Arrays.toString(dashes) : "")
+ '}';
}
return "TestSetup{id=" + id + ", shapeMode=" + shapeMode + ", closed=" + closed
+ ", fill"
+ ", windingRule=" + getWindingRule(windingRule) + '}';
}
private static String getCap(final int cap) {
switch (cap) {
case BasicStroke.CAP_BUTT:
return "CAP_BUTT";
case BasicStroke.CAP_ROUND:
return "CAP_ROUND";
case BasicStroke.CAP_SQUARE:
return "CAP_SQUARE";
default:
return "";
}
}
private static String getJoin(final int join) {
switch (join) {
case BasicStroke.JOIN_MITER:
return "JOIN_MITER";
case BasicStroke.JOIN_ROUND:
return "JOIN_ROUND";
case BasicStroke.JOIN_BEVEL:
return "JOIN_BEVEL";
default:
return "";
}
}
private static String getWindingRule(final int rule) {
switch (rule) {
case PathIterator.WIND_EVEN_ODD:
return "WIND_EVEN_ODD";
case PathIterator.WIND_NON_ZERO:
return "WIND_NON_ZERO";
default:
return "";
}
}
}
// --- utilities ---
private static final int DCM_ALPHA_MASK = 0xff000000;
public static BufferedImage newImage(final int w, final int h) {
return new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB_PRE);
}
public static BufferedImage computeDiffImage(final DiffContext testCtx,
final DiffContext testThCtx,
final BufferedImage tstImage,
final BufferedImage refImage,
final BufferedImage diffImage) {
final int[] aRefPix = ((DataBufferInt) refImage.getRaster().getDataBuffer()).getData();
final int[] aTstPix = ((DataBufferInt) tstImage.getRaster().getDataBuffer()).getData();
final int[] aDifPix = ((DataBufferInt) diffImage.getRaster().getDataBuffer()).getData();
// reset diff contexts:
testCtx.reset();
testThCtx.reset();
int ref, tst, dg, v;
for (int i = 0, len = aRefPix.length; i < len; i++) {
ref = aRefPix[i];
tst = aTstPix[i];
// grayscale diff:
dg = (r(ref) + g(ref) + b(ref)) - (r(tst) + g(tst) + b(tst));
// max difference on grayscale values:
v = (int) Math.ceil(Math.abs(dg / 3.0));
if (v <= THRESHOLD_DELTA) {
aDifPix[i] = 0;
} else {
aDifPix[i] = toInt(v, v, v);
testThCtx.add(v);
}
if (v != 0) {
testCtx.add(v);
}
}
testCtx.addNbPix(testThCtx.histPix.count);
if (!testThCtx.isDiff() || (testThCtx.histPix.count <= THRESHOLD_NBPIX)) {
return null;
}
return diffImage;
}
static void saveImage(final BufferedImage image, final File resDirectory, final String imageFileName) throws IOException {
final Iterator<ImageWriter> itWriters = ImageIO.getImageWritersByFormatName("PNG");
if (itWriters.hasNext()) {
final ImageWriter writer = itWriters.next();
final ImageWriteParam writerParams = writer.getDefaultWriteParam();
writerParams.setProgressiveMode(ImageWriteParam.MODE_DISABLED);
final File imgFile = new File(resDirectory, imageFileName);
if (!imgFile.exists() || imgFile.canWrite()) {
System.out.println("saveImage: saving image as PNG [" + imgFile + "]...");
imgFile.delete();
// disable cache in temporary files:
ImageIO.setUseCache(false);
final long start = System.nanoTime();
// PNG uses already buffering:
final ImageOutputStream imgOutStream = ImageIO.createImageOutputStream(new FileOutputStream(imgFile));
writer.setOutput(imgOutStream);
try {
writer.write(null, new IIOImage(image, null, null), writerParams);
} finally {
imgOutStream.close();
final long time = System.nanoTime() - start;
System.out.println("saveImage: duration= " + (time / 1000000l) + " ms.");
}
}
}
}
static int r(final int v) {
return (v >> 16 & 0xff);
}
static int g(final int v) {
return (v >> 8 & 0xff);
}
static int b(final int v) {
return (v & 0xff);
}
static int clamp127(final int v) {
return (v < 128) ? (v > -127 ? (v + 127) : 0) : 255;
}
static int toInt(final int r, final int g, final int b) {
return DCM_ALPHA_MASK | (r << 16) | (g << 8) | b;
}
/* stats */
static class StatInteger {
public final String name;
public long count = 0l;
public long sum = 0l;
public long min = Integer.MAX_VALUE;
public long max = Integer.MIN_VALUE;
StatInteger(String name) {
this.name = name;
}
void reset() {
count = 0l;
sum = 0l;
min = Integer.MAX_VALUE;
max = Integer.MIN_VALUE;
}
void add(int val) {
count++;
sum += val;
if (val < min) {
min = val;
}
if (val > max) {
max = val;
}
}
void add(long val) {
count++;
sum += val;
if (val < min) {
min = val;
}
if (val > max) {
max = val;
}
}
void add(StatInteger stat) {
count += stat.count;
sum += stat.sum;
if (stat.min < min) {
min = stat.min;
}
if (stat.max > max) {
max = stat.max;
}
}
public final double average() {
return ((double) sum) / count;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder(128);
toString(sb);
return sb.toString();
}
public final StringBuilder toString(final StringBuilder sb) {
sb.append(name).append("[n: ").append(count);
sb.append("] ");
if (count != 0) {
sb.append("sum: ").append(sum).append(" avg: ").append(trimTo3Digits(average()));
sb.append(" [").append(min).append(" | ").append(max).append("]");
}
return sb;
}
}
final static class Histogram extends StatInteger {
static final int BUCKET = 2;
static final int MAX = 20;
static final int LAST = MAX - 1;
static final int[] STEPS = new int[MAX];
static final int BUCKET_TH;
static {
STEPS[0] = 0;
STEPS[1] = 1;
for (int i = 2; i < MAX; i++) {
STEPS[i] = STEPS[i - 1] * BUCKET;
}
// System.out.println("Histogram.STEPS = " + Arrays.toString(STEPS));
if (THRESHOLD_DELTA % 2 != 0) {
throw new IllegalStateException("THRESHOLD_DELTA must be odd");
}
BUCKET_TH = bucket(THRESHOLD_DELTA);
}
static int bucket(int val) {
for (int i = 1; i < MAX; i++) {
if (val < STEPS[i]) {
return i - 1;
}
}
return LAST;
}
private final StatInteger[] stats = new StatInteger[MAX];
public Histogram(String name) {
super(name);
for (int i = 0; i < MAX; i++) {
stats[i] = new StatInteger(String.format("%5s .. %5s", STEPS[i], ((i + 1 < MAX) ? STEPS[i + 1] : "~")));
}
}
@Override
final void reset() {
super.reset();
for (int i = 0; i < MAX; i++) {
stats[i].reset();
}
}
@Override
final void add(int val) {
super.add(val);
stats[bucket(val)].add(val);
}
@Override
final void add(long val) {
add((int) val);
}
void add(Histogram hist) {
super.add(hist);
for (int i = 0; i < MAX; i++) {
stats[i].add(hist.stats[i]);
}
}
boolean isWorse(Histogram hist, boolean useTh) {
boolean worst = false;
if (!useTh && (hist.sum > sum)) {
worst = true;
} else {
long sumLoc = 0l;
long sumHist = 0l;
// use running sum:
for (int i = MAX - 1; i >= BUCKET_TH; i--) {
sumLoc += stats[i].sum;
sumHist += hist.stats[i].sum;
}
if (sumHist > sumLoc) {
worst = true;
}
}
/*
System.out.println("running sum worst:");
System.out.println("this ? " + toString());
System.out.println("worst ? " + hist.toString());
*/
return worst;
}
@Override
public final String toString() {
final StringBuilder sb = new StringBuilder(2048);
super.toString(sb).append(" { ");
for (int i = 0; i < MAX; i++) {
if (stats[i].count != 0l) {
sb.append("\n ").append(stats[i].toString());
}
}
return sb.append(" }").toString();
}
}
/**
* Adjust the given double value to keep only 3 decimal digits
* @param value value to adjust
* @return double value with only 3 decimal digits
*/
static double trimTo3Digits(final double value) {
return ((long) (1e3d * value)) / 1e3d;
}
static final class DiffContext {
public final Histogram histPix;
public final StatInteger nbPix;
DiffContext(String name) {
histPix = new Histogram("Diff Pixels [" + name + "]");
nbPix = new StatInteger("NbPixels [" + name + "]");
}
void reset() {
histPix.reset();
nbPix.reset();
}
void dump() {
if (isDiff()) {
System.out.println("Differences [" + histPix.name + "]:\n"
+ ((nbPix.count != 0) ? (nbPix.toString() + "\n") : "")
+ histPix.toString()
);
} else {
System.out.println("No difference for [" + histPix.name + "].");
}
}
void add(int val) {
histPix.add(val);
}
void add(DiffContext ctx) {
histPix.add(ctx.histPix);
if (ctx.nbPix.count != 0L) {
nbPix.add(ctx.nbPix);
}
}
void addNbPix(long val) {
if (val != 0L) {
nbPix.add(val);
}
}
void set(DiffContext ctx) {
reset();
add(ctx);
}
boolean isWorse(DiffContext ctx, boolean useTh) {
return histPix.isWorse(ctx.histPix, useTh);
}
boolean isDiff() {
return histPix.sum != 0l;
}
}
static double linelen(final double x0, final double y0,
final double x1, final double y1)
{
final double dx = x1 - x0;
final double dy = y1 - y0;
return Math.sqrt(dx * dx + dy * dy);
}
static double quadlen(final double x0, final double y0,
final double x1, final double y1,
final double x2, final double y2)
{
return (linelen(x0, y0, x1, y1)
+ linelen(x1, y1, x2, y2)
+ linelen(x0, y0, x2, y2)) / 2.0d;
}
static double curvelen(final double x0, final double y0,
final double x1, final double y1,
final double x2, final double y2,
final double x3, final double y3)
{
return (linelen(x0, y0, x1, y1)
+ linelen(x1, y1, x2, y2)
+ linelen(x2, y2, x3, y3)
+ linelen(x0, y0, x3, y3)) / 2.0d;
}
}