| /* |
| * Copyright (c) 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 |
| * @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(); |
| } |
| } |