Loads an image as a 'stamp'; the image's greyscale value (actually blue channel if it's colour) is used as alpha value for a new image with the specified colour. - Java 2D Graphics

Java examples for 2D Graphics:BufferedImage Scale

  1. HOME
  2. Java
  3. 2D Graphics
  4. BufferedImage Scale

Description

Loads an image as a 'stamp'; the image's greyscale value (actually blue channel if it's colour) is used as alpha value for a new image with the specified colour.

Demo Code

/*//  www  .  j a  va2  s  . c om
This file is part of leafdigital util.

util is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

util 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 for more details.

You should have received a copy of the GNU General Public License
along with util.  If not, see <http://www.gnu.org/licenses/>.

Copyright 2011 Samuel Marshall.
 */
import java.awt.*;
import java.awt.font.FontRenderContext;
import java.awt.image.BufferedImage;
import java.io.*;
import java.lang.reflect.Method;
import java.net.URL;
import javax.swing.JPanel;

public class Main{
    /** Used only if we need a component for MediaTracker */
    public static JPanel pStupid = null;
    /**
     * Loads an image as a 'stamp'; the image's greyscale value (actually
     * blue channel if it's colour) is used as alpha value for a new image
     * with the specified colour.
     * @param u Image URL
     * @param c Colour for stamp
     * @return New image in the defined colour
     * @throws IOException Any loading error
     */
    public static BufferedImage loadStamp(URL u, Color c)
            throws IOException {
        // Load image and copy into buffered image
        Image i = loadImage(u);
        BufferedImage bi = new BufferedImage(i.getWidth(null),
                i.getHeight(null), BufferedImage.TYPE_INT_ARGB);
        bi.getGraphics().drawImage(i, 0, 0, null);

        // Lame loop to do 'stamp' thing
        int colour = c.getRGB() & 0xffffff;
        for (int iY = 0; iY < bi.getHeight(); iY++) {
            for (int iX = 0; iX < bi.getWidth(); iX++) {
                int rgb = bi.getRGB(iX, iY);
                rgb = colour | ((rgb & 0xff) << 24);
                bi.setRGB(iX, iY, rgb);
            }
        }

        return bi;
    }
    /**
     * Loads any image from a URL.
     * @param u URL
     * @return Image
     * @throws IOException Any error
     */
    public static Image loadImage(URL u) throws IOException {
        return loadImage(u.openStream(), u.getPath());
    }
    /**
     * Loads an image (and waits for it to load completely).
     * @param is Input stream to load from
     * @param fileName File name (only used to check for a .jpg extension, rest can be anything)
     * @return Image
     * @throws IOException If image can't be loaded
     */
    public static Image loadImage(InputStream is, String fileName)
            throws IOException {
        if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) {
            return loadJPEG(is);
        } else {
            return loadOther(IOUtils.loadBytes(is));
        }
    }
    /**
     * Loads a JPEG image using Sun's loader in preference to  the standard one,
     * if it's available. (Probably there is no point in doing this any more...)
     * @param is Input stream
     * @return Image
     * @throws IOException
     */
    public static Image loadJPEG(InputStream is) throws IOException {
        // If Sun's codec is present, use it (for some ungodly reason, it's twice
        // as fast as the normal loader). Do reflection to avoid causing link errors
        // if it's unavailable
        try {
            Class<?> cJPEGCodec = Class
                    .forName("com.sun.image.codec.jpeg.JPEGCodec");
            Method m = cJPEGCodec.getDeclaredMethod("createJPEGDecoder",
                    InputStream.class);
            Object decoder = m.invoke(null, is);
            m = decoder.getClass().getDeclaredMethod(
                    "decodeAsBufferedImage");
            return (Image) m.invoke(decoder);
        } catch (Exception e) {
            return loadOther(IOUtils.loadBytes(is));
        }
    }
    /**
     * Loads an image that isn't JPEG (with default Java loader).
     * @param data
     * @return Image (ready for display)
     */
    public static Image loadOther(byte[] data) {
        Image iReturn;
        if (pStupid == null)
            pStupid = new JPanel();
        iReturn = Toolkit.getDefaultToolkit().createImage(data);
        waitImage(iReturn);
        return iReturn;
    }
    private static void waitImage(Image i) {
        MediaTracker mt = new MediaTracker(pStupid);
        mt.addImage(i, 1);
        try {
            mt.waitForAll();
        } catch (InterruptedException e2) {
        }
    }
}

Related Tutorials