Java BufferedImage Create getBufferedImage(String imagePath)

Description

get Buffered Image

License

Apache License

Declaration

public static BufferedImage getBufferedImage(String imagePath) throws Exception 

Method Source Code

//package com.java2s;
//License from project: Apache License 

import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.HeadlessException;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.Transparency;
import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.MalformedURLException;
import java.net.URL;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;

public class Main {
    public static BufferedImage getBufferedImage(String imagePath, boolean isRemote) throws Exception {
        return getBufferedImage(imagePath, isRemote, 0, 1 * 1000);
    }/*from   ww w.  ja v a2  s.  c  o  m*/

    public static BufferedImage getBufferedImage(String imagePath) throws Exception {
        return getBufferedImage(imagePath, false, 0, 1 * 1000);
    }

    public static BufferedImage getBufferedImage(String imagePath, int retryTimes, long sleep) throws Exception {
        return getBufferedImage(imagePath, false, retryTimes, sleep);
    }

    public static BufferedImage getBufferedImage(String imagePath, boolean isRemote, int retryTimes, long sleep)
            throws Exception {
        if (imagePath == null || imagePath.trim().length() == 0)
            throw new Exception("image url can not be empty");

        int count = 0;
        while (true) {
            try {
                if (isRemote)
                    return getRemote(imagePath);

                try {
                    return getLocal(imagePath);
                } catch (Throwable e) {
                    return getRemote(imagePath);
                }
            } catch (Throwable e) {
                if (count >= retryTimes) {
                    throw new Exception(e);
                }
                Thread.sleep(sleep);
            }
            count++;
        }
    }

    private static BufferedImage getRemote(String imagePath) throws MalformedURLException, IOException {
        URL url = new URL(imagePath.replace(" ", "%20"));
        try {
            return toBufferedImage(Toolkit.getDefaultToolkit().getImage(url));
        } catch (Throwable e1) {
            return ImageIO.read(url);
        }
    }

    private static BufferedImage getLocal(String imagePath) throws IOException {
        try {
            return toBufferedImage(Toolkit.getDefaultToolkit().getImage(imagePath));
        } catch (Throwable e) {
            return ImageIO.read(new File(imagePath));
        }
    }

    public static BufferedImage toBufferedImage(Image image) {
        if (image instanceof BufferedImage) {
            return (BufferedImage) image;
        }

        // This code ensures that all the pixels in the image are loaded
        image = new ImageIcon(image).getImage();

        // Determine if the image has transparent pixels; for this method's
        // implementation, see e661 Determining If an Image Has Transparent
        // Pixels
        // boolean hasAlpha = hasAlpha(image);

        // Create a buffered image with a format that's compatible with the
        // screen
        BufferedImage bimage = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try {
            // Determine the type of transparency of the new buffered image
            int transparency = Transparency.OPAQUE;
            /*
             * if (hasAlpha) { transparency = Transparency.BITMASK; }
             */

            // Create the buffered image
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            GraphicsConfiguration gc = gs.getDefaultConfiguration();
            bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
        } catch (HeadlessException e) {
            // The system does not have a screen
        }

        if (bimage == null) {
            // Create a buffered image using the default color model
            int type = BufferedImage.TYPE_INT_RGB;
            // int type = BufferedImage.TYPE_3BYTE_BGR;//by wang
            /*
             * if (hasAlpha) { type = BufferedImage.TYPE_INT_ARGB; }
             */
            bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
        }

        // Copy image to buffered image
        Graphics g = bimage.createGraphics();

        // Paint the image onto the buffered image
        g.drawImage(image, 0, 0, null);
        g.dispose();

        return bimage;
    }
}

Related

1. convertToBufferedImage(BufferedImage image, int imageType)
2. getBufferedImage(byte[] imgStr)
3. getBufferedImage(Component comp, BufferedImage image)
4. getBufferedImage(File file)
5. getBufferedImage(String imageFile, Component c)
6. getBufferedImageAsType(int type, BufferedImage image, int sizeX, int sizeY)
7. getBufferedImageBytes(BufferedImage bufferedImage)
8. getBufferedImaged(Image img, int width, int height)
9. getBufferedImageFrom3bytePixelArray(int[] rgb, int width, int height)