/*
* Copyright (c) 2002, 2007, Oracle and/or its affiliates. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of Oracle nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package j2dbench.tests;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.AlphaComposite;
import java.awt.Stroke;
import java.awt.BasicStroke;
import java.awt.GradientPaint;
import java.awt.LinearGradientPaint;
import java.awt.MultipleGradientPaint;
import java.awt.MultipleGradientPaint.CycleMethod;
import java.awt.MultipleGradientPaint.ColorSpaceType;
import java.awt.RadialGradientPaint;
import java.awt.RenderingHints;
import java.awt.TexturePaint;
import java.awt.geom.CubicCurve2D;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.PrintWriter;
import java.util.ArrayList;
import javax.swing.JComponent;
import j2dbench.Group;
import j2dbench.Node;
import j2dbench.Option;
import j2dbench.TestEnvironment;
public abstract class RenderTests extends GraphicsTests {
static Group renderroot;
static Group renderoptroot;
static Group rendertestroot;
static Group rendershaperoot;
static Option paintList;
static Option doAntialias;
static Option doAlphaColors;
static Option sizeList;
static Option strokeList;
static final int NUM_RANDOMCOLORS = 4096;
static final int NUM_RANDOMCOLORMASK = (NUM_RANDOMCOLORS - 1);
static Color randAlphaColors[];
static Color randOpaqueColors[];
static {
randOpaqueColors = new Color[NUM_RANDOMCOLORS];
randAlphaColors = new Color[NUM_RANDOMCOLORS];
for (int i = 0; i < NUM_RANDOMCOLORS; i++) {
int r = (int) (Math.random() * 255);
int g = (int) (Math.random() * 255);
int b = (int) (Math.random() * 255);
randOpaqueColors[i] = new Color(r, g, b);
randAlphaColors[i] = makeAlphaColor(randOpaqueColors[i], 32);
}
}
static boolean hasMultiGradient;
static {
try {
hasMultiGradient = (MultipleGradientPaint.class != null);
} catch (NoClassDefFoundError e) {
}
}
public static void init() {
renderroot = new Group(graphicsroot, "render", "Rendering Benchmarks");
renderoptroot = new Group(renderroot, "opts", "Rendering Options");
rendertestroot = new Group(renderroot, "tests", "Rendering Tests");
ArrayList paintStrs = new ArrayList();
ArrayList paintDescs = new ArrayList();
paintStrs.add("single");
paintDescs.add("Single Color");
paintStrs.add("random");
paintDescs.add("Random Color");
if (hasGraphics2D) {
paintStrs.add("gradient2");
paintDescs.add("2-color GradientPaint");
if (hasMultiGradient) {
paintStrs.add("linear2");
paintDescs.add("2-color LinearGradientPaint");
paintStrs.add("linear3");
paintDescs.add("3-color LinearGradientPaint");
paintStrs.add("radial2");
paintDescs.add("2-color RadialGradientPaint");
paintStrs.add("radial3");
paintDescs.add("3-color RadialGradientPaint");
}
paintStrs.add("texture20");
paintDescs.add("20x20 TexturePaint");
paintStrs.add("texture32");
paintDescs.add("32x32 TexturePaint");
}
String[] paintStrArr = new String[paintStrs.size()];
paintStrArr = (String[])paintStrs.toArray(paintStrArr);
String[] paintDescArr = new String[paintDescs.size()];
paintDescArr = (String[])paintDescs.toArray(paintDescArr);
paintList =
new Option.ObjectList(renderoptroot,
"paint", "Paint Type",
paintStrArr, paintStrArr,
paintStrArr, paintDescArr,
0x1);
((Option.ObjectList) paintList).setNumRows(5);
// add special RandomColorOpt for backwards compatibility with
// older options files
new RandomColorOpt();
if (hasGraphics2D) {
doAlphaColors =
new Option.Toggle(renderoptroot, "alphacolor",
"Set the alpha of the paint to 0.125",
Option.Toggle.Off);
doAntialias =
new Option.Toggle(renderoptroot, "antialias",
"Render shapes antialiased",
Option.Toggle.Off);
String strokeStrings[] = {
"width0",
"width1",
"width5",
"width20",
"dash0_5",
"dash1_5",
"dash5_20",
"dash20_50",
};
String strokeDescriptions[] = {
"Solid Thin lines",
"Solid Width 1 lines",
"Solid Width 5 lines",
"Solid Width 20 lines",
"Dashed Thin lines",
"Dashed Width 1 lines",
"Dashed Width 5 lines",
"Dashed Width 20 lines",
};
BasicStroke strokeObjects[] = {
new BasicStroke(0f),
new BasicStroke(1f),
new BasicStroke(5f),
new BasicStroke(20f),
new BasicStroke(0f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_MITER, 10f,
new float[] { 5f, 5f }, 0f),
new BasicStroke(1f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_MITER, 10f,
new float[] { 5f, 5f }, 0f),
new BasicStroke(5f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_MITER, 10f,
new float[] { 20f, 20f }, 0f),
new BasicStroke(20f, BasicStroke.CAP_SQUARE,
BasicStroke.JOIN_MITER, 10f,
new float[] { 50f, 50f }, 0f),
};
strokeList =
new Option.ObjectList(renderoptroot,
"stroke", "Stroke Type",
strokeStrings, strokeObjects,
strokeStrings, strokeDescriptions,
0x2);
((Option.ObjectList) strokeList).setNumRows(4);
}
new DrawDiagonalLines();
new DrawHorizontalLines();
new DrawVerticalLines();
new FillRects();
new DrawRects();
new FillOvals();
new DrawOvals();
new FillPolys();
new DrawPolys();
if (hasGraphics2D) {
rendershaperoot = new Group(rendertestroot, "shape",
"Shape Rendering Tests");
new FillCubics();
new DrawCubics();
new FillEllipse2Ds();
new DrawEllipse2Ds();
}
}
/**
* This "virtual Node" implementation is here to maintain backward
* compatibility with older J2DBench releases, specifically those
* options files that were created before we added the gradient/texture
* paint options in JDK 6. This class will translate the color settings
* from the old "randomcolor" option into the new "paint" option.
*/
private static class RandomColorOpt extends Node {
public RandomColorOpt() {
super(renderoptroot, "randomcolor",
"Use random colors for each shape");
}
public JComponent getJComponent() {
return null;
}
public void restoreDefault() {
// no-op
}
public void write(PrintWriter pw) {
// no-op (the random/single choice will be saved as part of
// the new "paint" option added to J2DBench in JDK 6)
}
public String setOption(String key, String value) {
String opts;
if (value.equals("On")) {
opts = "random";
} else if (value.equals("Off")) {
opts = "single";
} else if (value.equals("Both")) {
opts = "random,single";
} else {
return "Bad value";
}
return ((Option.ObjectList)paintList).setValueFromString(opts);
}
}
public static class Context extends GraphicsTests.Context {
int colorindex;
Color colorlist[];
}
public RenderTests(Group parent, String nodeName, String description) {
super(parent, nodeName, description);
addDependencies(renderoptroot, true);
}
public GraphicsTests.Context createContext() {
return new RenderTests.Context();
}
public void initContext(TestEnvironment env, GraphicsTests.Context ctx) {
super.initContext(env, ctx);
RenderTests.Context rctx = (RenderTests.Context) ctx;
boolean alphacolor;
if (hasGraphics2D) {
Graphics2D g2d = (Graphics2D) rctx.graphics;
if (env.isEnabled(doAntialias)) {
g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
}
alphacolor = env.isEnabled(doAlphaColors);
g2d.setStroke((Stroke) env.getModifier(strokeList));
} else {
alphacolor = false;
}
String paint = (String)env.getModifier(paintList);
if (paint.equals("single")) {
Color c = Color.darkGray;
if (alphacolor) {
c = makeAlphaColor(c, 32);
}
rctx.graphics.setColor(c);
} else if (paint.equals("random")) {
rctx.colorlist = alphacolor ? randAlphaColors : randOpaqueColors;
} else if (paint.equals("gradient2")) {
Color[] colors = makeGradientColors(2, alphacolor);
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(new GradientPaint(0.0f, 0.0f, colors[0],
10.0f, 10.0f, colors[1], true));
} else if (paint.equals("linear2")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeLinear(2, alphacolor));
} else if (paint.equals("linear3")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeLinear(3, alphacolor));
} else if (paint.equals("radial2")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeRadial(2, alphacolor));
} else if (paint.equals("radial3")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeRadial(3, alphacolor));
} else if (paint.equals("texture20")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeTexturePaint(20, alphacolor));
} else if (paint.equals("texture32")) {
Graphics2D g2d = (Graphics2D)rctx.graphics;
g2d.setPaint(makeTexturePaint(32, alphacolor));
} else {
throw new InternalError("Invalid paint mode");
}
}
private Color[] makeGradientColors(int numColors, boolean alpha) {
Color[] colors = new Color[] {Color.red, Color.blue,
Color.green, Color.yellow};
Color[] ret = new Color[numColors];
for (int i = 0; i < numColors; i++) {
ret[i] = alpha ? makeAlphaColor(colors[i], 32) : colors[i];
}
return ret;
}
private LinearGradientPaint makeLinear(int numColors, boolean alpha) {
float interval = 1.0f / (numColors - 1);
float[] fractions = new float[numColors];
for (int i = 0; i < fractions.length; i++) {
fractions[i] = i * interval;
}
Color[] colors = makeGradientColors(numColors, alpha);
return new LinearGradientPaint(0.0f, 0.0f,
10.0f, 10.0f,
fractions, colors,
CycleMethod.REFLECT);
}
private RadialGradientPaint makeRadial(int numColors, boolean alpha) {
float interval = 1.0f / (numColors - 1);
float[] fractions = new float[numColors];
for (int i = 0; i < fractions.length; i++) {
fractions[i] = i * interval;
}
Color[] colors = makeGradientColors(numColors, alpha);
return new RadialGradientPaint(0.0f, 0.0f, 10.0f,
fractions, colors,
CycleMethod.REFLECT);
}
private TexturePaint makeTexturePaint(int size, boolean alpha) {
int s2 = size / 2;
int type =
alpha ? BufferedImage.TYPE_INT_ARGB : BufferedImage.TYPE_INT_RGB;
BufferedImage img = new BufferedImage(size, size, type);
Color[] colors = makeGradientColors(4, alpha);
Graphics2D g2d = img.createGraphics();
g2d.setComposite(AlphaComposite.Src);
g2d.setColor(colors[0]);
g2d.fillRect(0, 0, s2, s2);
g2d.setColor(colors[1]);
g2d.fillRect(s2, 0, s2, s2);
g2d.setColor(colors[3]);
g2d.fillRect(0, s2, s2, s2);
g2d.setColor(colors[2]);
g2d.fillRect(s2, s2, s2, s2);
g2d.dispose();
Rectangle2D bounds = new Rectangle2D.Float(0, 0, size, size);
return new TexturePaint(img, bounds);
}
public static class DrawDiagonalLines extends RenderTests {
public DrawDiagonalLines() {
super(rendertestroot, "drawLine", "Draw Diagonal Lines");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
return Math.max(ctx.outdim.width, ctx.outdim.height);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x + size, y + size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x + size, y + size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class DrawHorizontalLines extends RenderTests {
public DrawHorizontalLines() {
super(rendertestroot, "drawLineHoriz",
"Draw Horizontal Lines");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
return ctx.outdim.width;
}
public Dimension getOutputSize(int w, int h) {
return new Dimension(w, 1);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x + size, y);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x + size, y);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class DrawVerticalLines extends RenderTests {
public DrawVerticalLines() {
super(rendertestroot, "drawLineVert",
"Draw Vertical Lines");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
return ctx.outdim.height;
}
public Dimension getOutputSize(int w, int h) {
return new Dimension(1, h);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x, y + size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawLine(x, y, x, y + size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class FillRects extends RenderTests {
public FillRects() {
super(rendertestroot, "fillRect", "Fill Rectangles");
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.fillRect(x, y, size, size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.fillRect(x, y, size, size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class DrawRects extends RenderTests {
public DrawRects() {
super(rendertestroot, "drawRect", "Draw Rectangles");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
int w = ctx.outdim.width;
int h = ctx.outdim.height;
if (w < 2 || h < 2) {
// If one dimension is less than 2 then there is no
// gap in the middle, so we get a solid filled rectangle.
return w * h;
}
return (w * 2) + ((h - 2) * 2);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawRect(x, y, size, size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawRect(x, y, size, size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class FillOvals extends RenderTests {
public FillOvals() {
super(rendertestroot, "fillOval", "Fill Ellipses");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
// Approximated
double xaxis = ctx.outdim.width / 2.0;
double yaxis = ctx.outdim.height / 2.0;
return (int) (xaxis * yaxis * Math.PI);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.fillOval(x, y, size, size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.fillOval(x, y, size, size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class DrawOvals extends RenderTests {
public DrawOvals() {
super(rendertestroot, "drawOval", "Draw Ellipses");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
/*
* Approximation: We figured that the vertical chord connecting
* the +45 deg and -45 deg points on the ellipse is about
* height/sqrt(2) pixels long. Likewise, the horizontal chord
* connecting the +45 deg and +135 deg points on the ellipse is
* about width/sqrt(2) pixels long. Each of these chords has
* a parallel on the opposite side of the respective axis (there
* are two horizontal chords and two vertical chords). Altogether
* this gives a reasonable approximation of the total number of
* pixels touched by the ellipse, so we have:
* 2*(w/sqrt(2)) + 2*(h/sqrt(2))
* == (2/sqrt(2))*(w+h)
* == (sqrt(2))*(w+h)
*/
return (int)(Math.sqrt(2.0)*(ctx.outdim.width+ctx.outdim.height));
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
if (rctx.animate) {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawOval(x, y, size, size);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
} else {
do {
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawOval(x, y, size, size);
} while (--numReps > 0);
}
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class FillPolys extends RenderTests {
public FillPolys() {
super(rendertestroot, "fillPoly", "Fill Hexagonal Polygons");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
/*
* The polygon is a hexagon inscribed inside the square but
* missing a triangle at each of the four corners of size
* (w/4) by (h/2).
*
* Putting 2 of these triangles together gives a rectangle
* of size (w/4) by (h/2).
*
* Putting 2 of these rectangles together gives a total
* missing rectangle size of (w/2) by (h/2).
*
* Thus, exactly one quarter of the whole square is not
* touched by the filled polygon.
*/
int size = ctx.outdim.width * ctx.outdim.height;
return size - (size / 4);
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
int size = rctx.size;
int x = rctx.initX;
int y = rctx.initY;
int hexaX[] = new int[6];
int hexaY[] = new int[6];
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
do {
hexaX[0] = x;
hexaX[1] = hexaX[5] = x+size/4;
hexaX[2] = hexaX[4] = x+size-size/4;
hexaX[3] = x+size;
hexaY[1] = hexaY[2] = y;
hexaY[0] = hexaY[3] = y+size/2;
hexaY[4] = hexaY[5] = y+size;
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.fillPolygon(hexaX, hexaY, 6);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class DrawPolys extends RenderTests {
public DrawPolys() {
super(rendertestroot, "drawPoly", "Draw Hexagonal Polygons");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
/*
* The two horizontal segments have exactly two pixels per column.
* Since the diagonals are more vertical than horizontal, using
* h*2 would be a good way to count the pixels in those sections.
* We then have to figure out the size of the remainder of the
* horizontal lines at top and bottom to get the answer:
*
* (diagonals less endpoints)*2 + (horizontals)*2
*
* or:
*
* (h-2)*2 + ((x+w-1-w/4)-(x+w/4)+1)*2
*
* since (w == h == size), we then have:
*
* (size - size/4 - 1) * 4
*/
int size = ctx.size;
if (size <= 1) {
return 1;
} else {
return (size - (size / 4) - 1) * 4;
}
}
public void runTest(Object ctx, int numReps) {
RenderTests.Context rctx = (RenderTests.Context) ctx;
// subtract 1 to account for the fact that lines are drawn to
// and including the final coordinate...
int size = rctx.size - 1;
int x = rctx.initX;
int y = rctx.initY;
int hexaX[] = new int[6];
int hexaY[] = new int[6];
Graphics g = rctx.graphics;
g.translate(rctx.orgX, rctx.orgY);
Color rCArray[] = rctx.colorlist;
int ci = rctx.colorindex;
do {
hexaX[0] = x;
hexaX[1] = hexaX[5] = x+size/4;
hexaX[2] = hexaX[4] = x+size-size/4;
hexaX[3] = x+size;
hexaY[1] = hexaY[2] = y;
hexaY[0] = hexaY[3] = y+size/2;
hexaY[4] = hexaY[5] = y+size;
if (rCArray != null) {
g.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g.drawPolygon(hexaX, hexaY, 6);
if ((x -= 3) < 0) x += rctx.maxX;
if ((y -= 1) < 0) y += rctx.maxY;
} while (--numReps > 0);
rctx.colorindex = ci;
g.translate(-rctx.orgX, -rctx.orgY);
}
}
public static class FillCubics extends RenderTests {
static final double relTmax = .5 - Math.sqrt(3) / 6;
static final double relYmax = ((6*relTmax - 9)*relTmax + 3)*relTmax;
public FillCubics() {
super(rendershaperoot, "fillCubic", "Fill Bezier Curves");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
/*
* The cubic only touches 2 quadrants in the square, thus
* at least half of the square is unfilled. The integrals
* to figure out the exact area are not trivial so for the
* other 2 quadrants, I'm going to guess that the cubic only
* encloses somewhere between 1/2 and 3/4ths of the pixels
* in those quadrants - we will say 5/8ths. Thus only
* 5/16ths of the total square is filled.
*/
// Note: 2x2 ends up hitting exactly 1 pixel...
int size = ctx.size;
if (size < 2) size = 2;
return size * size * 5 / 16;
}
public static class Context extends RenderTests.Context {
CubicCurve2D curve = new CubicCurve2D.Float();
}
public GraphicsTests.Context createContext() {
return new FillCubics.Context();
}
public void runTest(Object ctx, int numReps) {
FillCubics.Context cctx = (FillCubics.Context) ctx;
int size = cctx.size;
// Note: 2x2 ends up hitting exactly 1 pixel...
if (size < 2) size = 2;
int x = cctx.initX;
int y = cctx.initY;
int cpoffset = (int) (size/relYmax/2);
CubicCurve2D curve = cctx.curve;
Graphics2D g2d = (Graphics2D) cctx.graphics;
g2d.translate(cctx.orgX, cctx.orgY);
Color rCArray[] = cctx.colorlist;
int ci = cctx.colorindex;
do {
curve.setCurve(x, y+size/2.0,
x+size/2.0, y+size/2.0-cpoffset,
x+size/2.0, y+size/2.0+cpoffset,
x+size, y+size/2.0);
if (rCArray != null) {
g2d.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g2d.fill(curve);
if ((x -= 3) < 0) x += cctx.maxX;
if ((y -= 1) < 0) y += cctx.maxY;
} while (--numReps > 0);
cctx.colorindex = ci;
g2d.translate(-cctx.orgX, -cctx.orgY);
}
}
public static class DrawCubics extends RenderTests {
static final double relTmax = .5 - Math.sqrt(3) / 6;
static final double relYmax = ((6*relTmax - 9)*relTmax + 3)*relTmax;
public DrawCubics() {
super(rendershaperoot, "drawCubic", "Draw Bezier Curves");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
// Gross approximation
int size = ctx.size;
if (size < 2) size = 2;
return size;
}
public static class Context extends RenderTests.Context {
CubicCurve2D curve = new CubicCurve2D.Float();
}
public GraphicsTests.Context createContext() {
return new DrawCubics.Context();
}
public void runTest(Object ctx, int numReps) {
DrawCubics.Context cctx = (DrawCubics.Context) ctx;
int size = cctx.size;
// Note: 2x2 ends up hitting exactly 1 pixel...
if (size < 2) size = 2;
int x = cctx.initX;
int y = cctx.initY;
int cpoffset = (int) (size/relYmax/2);
CubicCurve2D curve = cctx.curve;
Graphics2D g2d = (Graphics2D) cctx.graphics;
g2d.translate(cctx.orgX, cctx.orgY);
Color rCArray[] = cctx.colorlist;
int ci = cctx.colorindex;
do {
curve.setCurve(x, y+size/2.0,
x+size/2.0, y+size/2.0-cpoffset,
x+size/2.0, y+size/2.0+cpoffset,
x+size, y+size/2.0);
if (rCArray != null) {
g2d.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
g2d.draw(curve);
if ((x -= 3) < 0) x += cctx.maxX;
if ((y -= 1) < 0) y += cctx.maxY;
} while (--numReps > 0);
cctx.colorindex = ci;
g2d.translate(-cctx.orgX, -cctx.orgY);
}
}
public static class FillEllipse2Ds extends RenderTests {
public FillEllipse2Ds() {
super(rendershaperoot, "fillEllipse2D", "Fill Ellipse2Ds");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
// Approximated (copied from FillOvals.pixelsTouched())
double xaxis = ctx.outdim.width / 2.0;
double yaxis = ctx.outdim.height / 2.0;
return (int) (xaxis * yaxis * Math.PI);
}
public static class Context extends RenderTests.Context {
Ellipse2D ellipse = new Ellipse2D.Float();
}
public GraphicsTests.Context createContext() {
return new FillEllipse2Ds.Context();
}
public void runTest(Object ctx, int numReps) {
FillEllipse2Ds.Context cctx = (FillEllipse2Ds.Context) ctx;
int size = cctx.size;
int x = cctx.initX;
int y = cctx.initY;
Ellipse2D ellipse = cctx.ellipse;
Graphics2D g2d = (Graphics2D) cctx.graphics;
g2d.translate(cctx.orgX, cctx.orgY);
Color rCArray[] = cctx.colorlist;
int ci = cctx.colorindex;
do {
if (rCArray != null) {
g2d.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
ellipse.setFrame(x, y, size, size);
g2d.fill(ellipse);
if ((x -= 3) < 0) x += cctx.maxX;
if ((y -= 1) < 0) y += cctx.maxY;
} while (--numReps > 0);
cctx.colorindex = ci;
g2d.translate(-cctx.orgX, -cctx.orgY);
}
}
public static class DrawEllipse2Ds extends RenderTests {
public DrawEllipse2Ds() {
super(rendershaperoot, "drawEllipse2D", "Draw Ellipse2Ds");
}
public int pixelsTouched(GraphicsTests.Context ctx) {
// Approximated (copied from DrawOvals.pixelsTouched())
return (int)(Math.sqrt(2.0)*(ctx.outdim.width+ctx.outdim.height));
}
public static class Context extends RenderTests.Context {
Ellipse2D ellipse = new Ellipse2D.Float();
}
public GraphicsTests.Context createContext() {
return new DrawEllipse2Ds.Context();
}
public void runTest(Object ctx, int numReps) {
DrawEllipse2Ds.Context cctx = (DrawEllipse2Ds.Context) ctx;
int size = cctx.size;
int x = cctx.initX;
int y = cctx.initY;
Ellipse2D ellipse = cctx.ellipse;
Graphics2D g2d = (Graphics2D) cctx.graphics;
g2d.translate(cctx.orgX, cctx.orgY);
Color rCArray[] = cctx.colorlist;
int ci = cctx.colorindex;
do {
if (rCArray != null) {
g2d.setColor(rCArray[ci++ & NUM_RANDOMCOLORMASK]);
}
ellipse.setFrame(x, y, size, size);
g2d.draw(ellipse);
if ((x -= 3) < 0) x += cctx.maxX;
if ((y -= 1) < 0) y += cctx.maxY;
} while (--numReps > 0);
cctx.colorindex = ci;
g2d.translate(-cctx.orgX, -cctx.orgY);
}
}
}