/*
* Copyright (c) 2016, 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 8139183
* @summary Test verifies whether alpha channel of a translucent
* image is proper or not after scaling through drawImage.
* @run main ScaledImageAlphaTest
*/
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.awt.image.VolatileImage;
public class ScaledImageAlphaTest {
static final int translucentAlpha = 128, opaqueAlpha = 255;
static final int[] translucentVariants = new int[] {
BufferedImage.TYPE_INT_ARGB,
BufferedImage.TYPE_INT_ARGB_PRE,
BufferedImage.TYPE_4BYTE_ABGR,
BufferedImage.TYPE_4BYTE_ABGR_PRE
};
static final int[] alphaValues = new int[] {
translucentAlpha,
opaqueAlpha
};
static int width = 50, height = 50;
static int scaleX = 5, scaleY = 5, scaleWidth = 40, scaleHeight = 40;
private static void verifyAlpha(Color color, int alpha) {
/* if extracted alpha value is equal alpha that we set
* for background color, alpha channel is not lost
* while scaling otherwise we have lost alpha channel.
*/
int extractedAlpha = color.getAlpha();
if (extractedAlpha != alpha) {
throw new RuntimeException("Alpha channel for background"
+ " is lost while scaling");
}
}
private static void validateBufferedImageAlpha() {
Color backgroundColor, extractedColor;
// verify for all translucent buffered image types
for (int type : translucentVariants) {
// verify for both opaque and translucent background color
for (int alpha : alphaValues) {
// create BufferedImage of dimension (50,50)
BufferedImage img = new
BufferedImage(width, height, type);
Graphics2D imgGraphics = (Graphics2D)img.getGraphics();
/* scale image to smaller dimension and set any
* background color with alpha.
*/
backgroundColor = new Color(0, 255, 0, alpha);
imgGraphics.
drawImage(img, scaleX, scaleY, scaleWidth, scaleHeight,
backgroundColor, null);
imgGraphics.dispose();
/* get pixel information for background color with
* scaled coordinates.
*/
extractedColor = new Color(img.getRGB(scaleX, scaleY), true);
verifyAlpha(extractedColor, alpha);
}
}
}
private static void validateVolatileImageAlpha() {
Color backgroundColor, extractedColor;
VolatileImage img;
BufferedImage bufImg = new
BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
for (int alpha : alphaValues) {
backgroundColor = new Color(0, 255, 0, alpha);
do {
img = createVolatileImage(width, height,
Transparency.TRANSLUCENT);
Graphics2D imgGraphics = (Graphics2D)img.getGraphics();
// clear VolatileImage as by default it has white opaque image
imgGraphics.setComposite(AlphaComposite.Clear);
imgGraphics.fillRect(0,0, width, height);
imgGraphics.setComposite(AlphaComposite.SrcOver);
/* scale image to smaller dimension and set background color
* to green with translucent alpha.
*/
imgGraphics.
drawImage(img, scaleX, scaleY, scaleWidth, scaleHeight,
backgroundColor, null);
//get BufferedImage out of VolatileImage
bufImg = img.getSnapshot();
imgGraphics.dispose();
} while (img.contentsLost());
/* get pixel information for background color with
* scaled coordinates.
*/
extractedColor = new Color(bufImg.getRGB(scaleX, scaleY), true);
verifyAlpha(extractedColor, alpha);
}
}
private static VolatileImage createVolatileImage(int width, int height,
int transparency) {
GraphicsEnvironment ge = GraphicsEnvironment.
getLocalGraphicsEnvironment();
GraphicsConfiguration gc = ge.getDefaultScreenDevice().
getDefaultConfiguration();
VolatileImage image = gc.createCompatibleVolatileImage(width, height,
transparency);
return image;
}
public static void main(String[] args) {
// test alpha channel with different types of BufferedImage
validateBufferedImageAlpha();
// test alpha channel with VolatileImage
validateVolatileImageAlpha();
}
}