Java example source code file (PngOutputTypeTest.java)

This example Java source code file (PngOutputTypeTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

awt, bufferedimage, color, dom, failed, file, iiometadata, image, imageinputstream, imageio, imagereadparam, imagetypespecifier, ioexception, namednodemap, node, pngoutputtypetest, runtimeexception, string, util

The PngOutputTypeTest.java Java example source code

/*
 * Copyright (c) 2007, 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     6549882
 * @summary Test verifies that PNG image reader creates buffered image
 *          of standart type for 8 bpp images with color type RGB or RGBAlpha
 *
 * @run     main PngOutputTypeTest
 */

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.Iterator;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.ImageTypeSpecifier;
import javax.imageio.metadata.IIOMetadata;
import javax.imageio.stream.ImageInputStream;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class PngOutputTypeTest {

    public static void main(String[] args) throws IOException {

        new PngOutputTypeTest(BufferedImage.TYPE_INT_RGB).doTest();

        new PngOutputTypeTest(BufferedImage.TYPE_INT_ARGB).doTest();

    }

    ImageInputStream iis;

    ImageReader reader;

    public PngOutputTypeTest(int type) throws IOException {
        this(createTestImage(type));
    }

    public PngOutputTypeTest(File f) throws IOException {
        this(ImageIO.createImageInputStream(f));
    }

    public PngOutputTypeTest(ImageInputStream iis) throws IOException {
        this.iis = iis;
        reader = ImageIO.getImageReaders(iis).next();
        reader.setInput(iis);
    }

    BufferedImage def;
    BufferedImage raw;

    ImageTypeSpecifier raw_type;

    public void doTest() throws IOException {
        /*
         * This test verifies that png images with color type RGB or RGBA
         * are decoded as buffered  image of some standard type.
         *
         * So we need to be sure that image provided by
         * user has required color type - RGB or RGBA
         */
        if (!checkImageType()) {
            System.out.println("Test IGNORED!");
            return;
        }

        def = reader.read(0);
        System.out.println("Default image type: " + def.getType());
        if (def == null || def.getType() == BufferedImage.TYPE_CUSTOM) {
            throw new RuntimeException("Test FAILED!");
        }

        raw_type = reader.getRawImageType(0);
        ImageReadParam param = reader.getDefaultReadParam();
        param.setDestinationType(raw_type);

        System.out.println("Reading with raw image type...");
        raw = reader.read(0, param);
        System.out.println("Type of raw image is " + raw.getType());

        compare(def, raw);

        Iterator<ImageTypeSpecifier> types = reader.getImageTypes(0);
        while (types.hasNext()) {
            ImageTypeSpecifier t = types.next();
            System.out.println("Test type: " + t);
            param.setDestinationType(t);

            BufferedImage img = reader.read(0, param);
            System.out.println("Result type: " + img.getType());

            compare(def, img);
            System.out.println("Done.\n");
        }

        System.out.println("Test PASSED.");
    }

    private boolean checkImageType() throws IOException {
        IIOMetadata md  = null;
        try {
            md = reader.getImageMetadata(0);
        } catch (IOException e) {
            return false;
        }

        String format = md.getNativeMetadataFormatName();

        Node root = md.getAsTree(format);

        Node ihdr = getNode(root, "IHDR");
        if (ihdr == null) {
            throw new RuntimeException("No ihdr node: invalid png image!");
        }

        String colorType = getAttributeValue(ihdr, "colorType");
        System.out.println("ColorType: " + colorType);
        if ("RGB".equals(colorType) || "RGBAlpha".equals(colorType)) {
            // we shuld chek bitDepth
            System.out.println("Good color type!");
            String bitDepthStr = getAttributeValue(ihdr, "bitDepth");
            System.out.println("bitDepth: " + bitDepthStr);
            int bitDepth = -1;
            try {
                bitDepth = Integer.parseInt(bitDepthStr);
            } catch (NumberFormatException e) {
                throw new RuntimeException("Invalid bitDepth!");
            }
            if (bitDepth == 8) {
                /*
                 * This image is RGB or RGBA color type and
                 * 8 bit tepth. so it can be used for test
                 */
                return true;
            }
        }

        return false;
    }

    private String getAttributeValue(Node n, String attrname) {
        NamedNodeMap attrs = n.getAttributes();
        if (attrs == null) {
            return null;
        } else {
            Node a = attrs.getNamedItem(attrname);
            if (a == null) {
                return null;
            } else {
                return a.getNodeValue();
            }
        }
    }

    private Node getNode(Node root, String name) {
        Node n = root;
        return lookupNode(n, name);
    }

    private Node lookupNode(Node n, String name) {
        if (n == null) {
            return null;
        }
        if (name.equals(n.getNodeName())) {
            return n;
        } else {
            // may be next on this level?
            Node res = lookupNode(n.getNextSibling(), name);

            if (res != null) {
                return res;
            } else {
                /// try children then
                return lookupNode(n.getFirstChild(), name);
            }
        }
    }

    private static void compare(BufferedImage a, BufferedImage b) {
        int w = a.getWidth();
        int h = a.getHeight();

        if (w != b.getWidth() || h != b.getHeight()) {
            throw new RuntimeException("Test FAILED!");
        }

        for (int y = 0; y < h; y++) {
            for (int x = 0; x < w; x++) {
                if (a.getRGB(x, y) != b.getRGB(x, y)) {
                    throw new RuntimeException("Test FAILED!");
                }
            }
        }
    }

    static Color[] colors = new Color[] { Color.red, Color.green, Color.blue };

    private static ImageInputStream createTestImage(int type) throws IOException  {
        int w = 100;
        int h = 100;

        BufferedImage img = new BufferedImage(w, h, type);

        int dx = w / colors.length;

        for (int i = 0; i < colors.length; i++) {
            for (int x = i *dx; (x < (i + 1) * dx) && (x < w) ; x++) {
                for (int y = 0; y < h; y++) {
                    img.setRGB(x, y, colors[i].getRGB());
                }
            }
        }

        File pwd = new File(".");
        File out = File.createTempFile("rgba_", ".png", pwd);
        System.out.println("Create file: " + out.getAbsolutePath());
        ImageIO.write(img, "PNG", out);
        return ImageIO.createImageInputStream(out);
    }
}