1 /*
   2  * Copyright (c) 2013, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.awt.Color;
  25 import java.awt.Graphics;
  26 import java.awt.Graphics2D;
  27 import java.awt.Image;
  28 import java.awt.image.BufferedImage;
  29 import sun.awt.SunHints;
  30 import java.awt.geom.AffineTransform;
  31 import java.util.Arrays;
  32 import java.util.List;
  33 import sun.awt.image.MultiResolutionImage;
  34 
  35 /**
  36  * @test @bug 8011059
  37  * @author Alexander Scherbatiy
  38  * @summary Test MultiResolution image loading and painting with various scaling
  39  *          combinations
  40  * @modules java.desktop/sun.awt
  41  *          java.desktop/sun.awt.image
  42  */
  43 public class MultiResolutionImageCommonTest {
  44 
  45     private static final int IMAGE_WIDTH = 300;
  46     private static final int IMAGE_HEIGHT = 200;
  47     private static final Color COLOR_1X = Color.GREEN;
  48     private static final Color COLOR_2X = Color.BLUE;
  49 
  50     public static void main(String[] args) throws Exception {
  51         testCustomMultiResolutionImage();
  52         System.out.println("Test passed.");
  53     }
  54 
  55     public static void testCustomMultiResolutionImage() {
  56         testCustomMultiResolutionImage(false);
  57         testCustomMultiResolutionImage(true);
  58     }
  59 
  60     public static void testCustomMultiResolutionImage(
  61             boolean enableImageScaling) {
  62 
  63         Image image = new MultiResolutionBufferedImage();
  64 
  65         // Same image size
  66         BufferedImage bufferedImage = new BufferedImage(
  67                 IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
  68         Graphics2D g2d = (Graphics2D) bufferedImage.getGraphics();
  69         setImageScalingHint(g2d, enableImageScaling);
  70         g2d.drawImage(image, 0, 0, null);
  71         checkColor(bufferedImage.getRGB(
  72                 3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
  73 
  74         // Twice image size
  75         bufferedImage = new BufferedImage(2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,
  76                 BufferedImage.TYPE_INT_RGB);
  77         g2d = (Graphics2D) bufferedImage.getGraphics();
  78         setImageScalingHint(g2d, enableImageScaling);
  79         g2d.drawImage(image, 0, 0, 2 * IMAGE_WIDTH,
  80                 2 * IMAGE_HEIGHT, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
  81         checkColor(bufferedImage.getRGB(3 * IMAGE_WIDTH / 2,
  82                 3 * IMAGE_HEIGHT / 2), enableImageScaling);
  83 
  84         // Scale 2x
  85         bufferedImage = new BufferedImage(
  86                 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
  87         g2d = (Graphics2D) bufferedImage.getGraphics();
  88         setImageScalingHint(g2d, enableImageScaling);
  89         g2d.scale(2, 2);
  90         g2d.drawImage(image, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
  91         checkColor(bufferedImage.getRGB(
  92                 3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
  93 
  94         // Rotate
  95         bufferedImage = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT,
  96                 BufferedImage.TYPE_INT_RGB);
  97         g2d = (Graphics2D) bufferedImage.getGraphics();
  98         setImageScalingHint(g2d, enableImageScaling);
  99         g2d.drawImage(image, 0, 0, null);
 100         g2d.rotate(Math.PI / 4);
 101         checkColor(bufferedImage.getRGB(
 102                 3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
 103 
 104         // Scale 2x and Rotate
 105         bufferedImage = new BufferedImage(
 106                 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
 107         g2d = (Graphics2D) bufferedImage.getGraphics();
 108         setImageScalingHint(g2d, enableImageScaling);
 109         g2d.scale(-2, 2);
 110         g2d.rotate(-Math.PI / 10);
 111         g2d.drawImage(image, -IMAGE_WIDTH, 0, IMAGE_WIDTH, IMAGE_HEIGHT, null);
 112         checkColor(bufferedImage.getRGB(
 113                 3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
 114 
 115         // General Transform
 116         bufferedImage = new BufferedImage(
 117                 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
 118         g2d = (Graphics2D) bufferedImage.getGraphics();
 119         setImageScalingHint(g2d, enableImageScaling);
 120         float delta = 0.05f;
 121         float cos = 1 - delta * delta / 2;
 122         float sin = 1 + delta;
 123         AffineTransform transform
 124                 = new AffineTransform(2 * cos, 0.1, 0.3, -2 * sin, 10, -5);
 125         g2d.setTransform(transform);
 126         g2d.drawImage(image, 0, -IMAGE_HEIGHT, IMAGE_WIDTH, IMAGE_HEIGHT, null);
 127         checkColor(bufferedImage.getRGB(
 128                 3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
 129 
 130         int D = 10;
 131         // From Source to small Destination region
 132         bufferedImage = new BufferedImage(
 133                 IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
 134         g2d = (Graphics2D) bufferedImage.getGraphics();
 135         setImageScalingHint(g2d, enableImageScaling);
 136         g2d.drawImage(image, IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2,
 137                 IMAGE_WIDTH - D, IMAGE_HEIGHT - D,
 138                 D, D, IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);
 139         checkColor(bufferedImage.getRGB(
 140                 3 * IMAGE_WIDTH / 4, 3 * IMAGE_HEIGHT / 4), false);
 141 
 142         // From Source to large Destination region
 143         bufferedImage = new BufferedImage(
 144                 2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
 145         g2d = (Graphics2D) bufferedImage.getGraphics();
 146         setImageScalingHint(g2d, enableImageScaling);
 147         g2d.drawImage(image, D, D, 2 * IMAGE_WIDTH - D, 2 * IMAGE_HEIGHT - D,
 148                 IMAGE_WIDTH / 2, IMAGE_HEIGHT / 2,
 149                 IMAGE_WIDTH - D, IMAGE_HEIGHT - D, null);
 150         checkColor(bufferedImage.getRGB(
 151                 3 * IMAGE_WIDTH / 2, 3 * IMAGE_HEIGHT / 2), enableImageScaling);
 152     }
 153 
 154     static class MultiResolutionBufferedImage extends BufferedImage
 155             implements MultiResolutionImage {
 156 
 157         Image highResolutionImage;
 158 
 159         public MultiResolutionBufferedImage() {
 160             super(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_RGB);
 161             highResolutionImage = new BufferedImage(
 162                     2 * IMAGE_WIDTH, 2 * IMAGE_HEIGHT,
 163                     BufferedImage.TYPE_INT_RGB);
 164             draw(getGraphics(), 1);
 165             draw(highResolutionImage.getGraphics(), 2);
 166         }
 167 
 168         final void draw(Graphics graphics, float resolution) {
 169             Graphics2D g2 = (Graphics2D) graphics;
 170             g2.scale(resolution, resolution);
 171             g2.setColor((resolution == 1) ? COLOR_1X : COLOR_2X);
 172             g2.fillRect(0, 0, IMAGE_WIDTH, IMAGE_HEIGHT);
 173         }
 174 
 175         @Override
 176         public Image getResolutionVariant(int width, int height) {
 177             return ((width <= getWidth() && height <= getHeight()))
 178                     ? this : highResolutionImage;
 179         }
 180 
 181         @Override
 182         public List<Image> getResolutionVariants() {
 183             return Arrays.asList(this, highResolutionImage);
 184         }
 185     }
 186 
 187     static void setImageScalingHint(
 188             Graphics2D g2d, boolean enableImageScaling) {
 189         g2d.setRenderingHint(SunHints.KEY_RESOLUTION_VARIANT, enableImageScaling
 190                 ? SunHints.VALUE_RESOLUTION_VARIANT_ON
 191                 : SunHints.VALUE_RESOLUTION_VARIANT_OFF);
 192     }
 193 
 194     static void checkColor(int rgb, boolean isImageScaled) {
 195 
 196         if (!isImageScaled && COLOR_1X.getRGB() != rgb) {
 197             throw new RuntimeException("Wrong 1x color: " + new Color(rgb));
 198         }
 199 
 200         if (isImageScaled && COLOR_2X.getRGB() != rgb) {
 201             throw new RuntimeException("Wrong 2x color" + new Color(rgb));
 202         }
 203     }
 204 
 205 }