/*
* Copyright (c) 2005, 2016, 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
* @key headful
* @bug 4832224 6322584 6328478 6328481 6322580 6588884 6587863
* @summary Verifies that the pixelization of simple primitives (drawLine,
* fillRect, drawRect, fill, draw) with the OGL pipeline enabled
* matches that produced by our software loops. (The primitives tested here
* are simple enough that the OGL results should match the software results
* exactly.) There is some overlap with PolyVertTest as we test both
* solid and XOR rendering here, but this testcase is a bit simpler and
* more appropriate for quick OGL testing. This test is also useful for
* comparing quality between our X11/GDI and software pipelines.
* @run main/othervm SimplePrimQuality
* @run main/othervm -Dsun.java2d.opengl=True SimplePrimQuality
* @author campbelc
*/
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
public class SimplePrimQuality extends Canvas {
private static final int SIZE = 300;
private static boolean done;
private static boolean testVI;
private static volatile BufferedImage capture;
private static void doCapture(Component test) {
// Grab the screen region
try {
Robot robot = new Robot();
Point pt1 = test.getLocationOnScreen();
Rectangle rect =
new Rectangle(pt1.x, pt1.y, test.getWidth(), test.getHeight());
capture = robot.createScreenCapture(rect);
} catch (Exception e) {
e.printStackTrace();
}
}
private static final int[][] rpts = {
{2, 0, 0, 0},
{12, 0, 1, 0},
{22, 0, 0, 1},
{32, 0, 1, 1},
{42, 0, 2, 1},
{52, 0, 1, 2},
{62, 0, 2, 2},
{72, 0, 5, 5},
{82, 0, 10, 10},
{97, 0, 15, 15},
};
private void drawLine(Graphics2D g, int x, int y, int dx, int dy) {
g.drawLine(x, y, x + dx, y + dy);
}
private void drawLines(Graphics2D g, int s) {
drawLine(g, 2, 0, 0, 0);
drawLine(g, 12, 0, 0, s);
drawLine(g, 22, 0, s, 0);
drawLine(g, 32, 0, s, s);
drawLine(g, 42, 0, 0, -s);
drawLine(g, 52, 0, -s, 0);
drawLine(g, 62, 0, -s, -s);
drawLine(g, 72, 0, -s, s);
drawLine(g, 82, 0, s, -s);
}
private void fillRects(Graphics2D g) {
for (int i = 0; i < rpts.length; i++) {
g.fillRect(rpts[i][0], rpts[i][1], rpts[i][2], rpts[i][3]);
}
}
private void drawRects(Graphics2D g) {
for (int i = 0; i < rpts.length; i++) {
g.drawRect(rpts[i][0], rpts[i][1], rpts[i][2], rpts[i][3]);
}
}
private void fillOvals(Graphics2D g) {
for (int i = 0; i < rpts.length; i++) {
// use fill() instead of fillOval(), since the former is more
// likely to be consistent with our software loops when the
// OGL pipeline cannot be enabled
g.fill(new Ellipse2D.Float(rpts[i][0], rpts[i][1],
rpts[i][2], rpts[i][3]));
}
}
private void drawOvals(Graphics2D g) {
for (int i = 0; i < rpts.length; i++) {
// use draw() instead of drawOval(), since the former is more
// likely to be consistent with our software loops when the
// OGL pipeline cannot be enabled
g.draw(new Ellipse2D.Float(rpts[i][0], rpts[i][1],
rpts[i][2], rpts[i][3]));
}
}
private void renderShapes(Graphics2D g) {
// drawLine tests...
g.translate(0, 5);
drawLines(g, 1);
g.translate(0, 10);
drawLines(g, 4);
// fillRect tests...
g.translate(0, 10);
fillRects(g);
// drawRect tests...
g.translate(0, 20);
drawRects(g);
// fillOval tests...
g.translate(0, 20);
fillOvals(g);
// drawOval tests...
g.translate(0, 20);
drawOvals(g);
}
private void renderTest(Graphics2D g, int w, int h) {
// on the left side, render the shapes in solid mode
g.setColor(Color.black);
g.fillRect(0, 0, w, h);
g.setColor(Color.green);
renderShapes(g);
// on the right side, render the shapes in XOR mode
g.setTransform(AffineTransform.getTranslateInstance(SIZE/2, 0));
g.setXORMode(Color.black);
renderShapes(g);
g.setTransform(AffineTransform.getTranslateInstance(SIZE/2, 0));
renderShapes(g);
}
public void paint(Graphics g) {
Graphics2D g2d = (Graphics2D)g;
renderTest(g2d, SIZE, SIZE);
Toolkit.getDefaultToolkit().sync();
synchronized (this) {
if (!done) {
doCapture(this);
done = true;
}
notifyAll();
}
}
public Dimension getPreferredSize() {
return new Dimension(SIZE, SIZE);
}
public static void main(String[] args) {
boolean show = false;
for (String arg : args) {
if (arg.equals("-testvi")) {
System.out.println("Testing VolatileImage, not screen");
testVI = true;
} else if (arg.equals("-show")) {
show = true;
}
}
SimplePrimQuality test = new SimplePrimQuality();
Frame frame = new Frame();
frame.add(test);
frame.pack();
frame.setVisible(true);
// Wait until the component's been painted
synchronized (test) {
while (!done) {
try {
test.wait();
} catch (InterruptedException e) {
throw new RuntimeException("Failed: Interrupted");
}
}
}
// REMIND: We will allow this test to pass silently on Windows
// (when OGL is not enabled) until we fix the GDI pipeline so that
// its stroked/filled GeneralPaths match our software loops (see
// 6322554). This check should be removed when 6322554 is fixed.
GraphicsConfiguration gc = frame.getGraphicsConfiguration();
if (gc.getClass().getSimpleName().startsWith("Win")) {
System.out.println("GDI pipeline detected: " +
"test considered PASSED");
frame.dispose();
return;
}
if (testVI) {
// render to a VI instead of the screen
VolatileImage vi = frame.createVolatileImage(SIZE, SIZE);
do {
vi.validate(frame.getGraphicsConfiguration());
Graphics2D g1 = vi.createGraphics();
test.renderTest(g1, SIZE, SIZE);
g1.dispose();
capture = vi.getSnapshot();
} while (vi.contentsLost());
frame.dispose();
}
if (!show) {
frame.dispose();
}
if (capture == null) {
throw new RuntimeException("Error capturing the rendering");
}
// Create reference image
int w = SIZE, h = SIZE;
BufferedImage refimg = new BufferedImage(w, h,
BufferedImage.TYPE_INT_RGB);
Graphics2D g = refimg.createGraphics();
test.renderTest(g, w, h);
g.dispose();
// Test pixels
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
int actual = capture.getRGB(x, y);
int expected = refimg.getRGB(x, y);
if (actual != expected) {
String expectedName = "SimplePrimQuality_expected.png";
String actualName = "SimplePrimQuality_actual.png";
try {
System.out.println("Writing expected image to: "+
expectedName);
ImageIO.write(refimg, "png", new File(expectedName));
System.out.println("Writing actual image to: "+
actualName);
ImageIO.write(capture, "png", new File(actualName));
} catch (IOException ex) {}
throw new RuntimeException("Test failed at x="+x+" y="+y+
" (expected="+
Integer.toHexString(expected) +
" actual="+
Integer.toHexString(actual) +
")");
}
}
}
}
}