Application: gvSIG desktop » Library: org.gvsig.tools

package org.gvsig.tools.swing.impl;

import java.awt.Graphics2D;

import java.awt.Image;

import java.awt.MediaTracker;

import java.awt.RenderingHints;

import java.awt.geom.AffineTransform;

import java.awt.image.BufferedImage;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.imageio.ImageIO;

import javax.swing.ImageIcon;

import org.apache.commons.codec.DecoderException;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.IOUtils;

import org.gvsig.tools.swing.api.SimpleImage;

/**

 *

 * @author jjdelcerro

 */

public class DefaultSimpleImage implements SimpleImage {

    BufferedImage image = null;

    public static BufferedImage toBufferedImage(Image img) {

        if (img instanceof BufferedImage) {

            return (BufferedImage) img;

        }

        // Create a buffered image with transparency

        BufferedImage bimage = new BufferedImage(

                img.getWidth(null), 

                img.getHeight(null), 

                BufferedImage.TYPE_INT_ARGB

        );

        // Draw the image on to the buffered image

        Graphics2D bGr = bimage.createGraphics();

        bGr.drawImage(img, 0, 0, null);

        bGr.dispose();

        return bimage;

    }

    public DefaultSimpleImage() {

    }

    public DefaultSimpleImage(BufferedImage image) {

        this.image = image;

    }

    public DefaultSimpleImage(Object source) {

        this.image = this.load(source);

    }

    public boolean isEmpty() {

        return this.image == null;

    }

    public BufferedImage getBufferedImage() {

        return this.image;

    }

    public void set(BufferedImage image) {

        this.image = image;

    }

    public void set(Object source) {

        this.image = this.load(source);

    }

    private BufferedImage load(Object source) {

        BufferedImage theImage = null;

        try {

            if (source instanceof BufferedImage) {

                return (BufferedImage) source;

            } else if (source instanceof ImageIcon ) {

                ImageIcon icon = (ImageIcon)source;

                int loadStatus = icon.getImageLoadStatus();

                if( loadStatus != MediaTracker.COMPLETE ) {

                    icon.getDescription();

                }

                return toBufferedImage(icon.getImage());

            } else if (source instanceof Image) {

                return toBufferedImage((Image) source);

            } else if (source instanceof byte[]) {

                ByteArrayInputStream is = new ByteArrayInputStream((byte[]) source);

                theImage = ImageIO.read(is);

            } else if (source instanceof File) {

                theImage = ImageIO.read((File) source);

            } else if (source instanceof URL) {

                theImage = ImageIO.read((URL) source);

            } else if (source instanceof String) {

                InputStream is;

                String s = (String) source;

                File f = new File(s);

                if (f.exists()) {

                    is = new FileInputStream(f);

                } else {

                    try {

                        URL url = new URL(s);

                        is = url.openStream();

                        is.available(); // Force exception if is null

                    } catch (Exception ex) {

                        try {

                            byte[] data = Hex.decodeHex(s.toCharArray());

                            is = new ByteArrayInputStream(data);

                        } catch (DecoderException ex2) {

                            try {

                                byte[] data = Base64.decodeBase64(s);

                                is = new ByteArrayInputStream(data);

                            } catch (Exception ex3) {

                                return null;

                            }

                        }

                    }

                }

                theImage = ImageIO.read(is);

                IOUtils.closeQuietly(is);

            }

        } catch (IOException ex) {

            return null;

        }

        return theImage;

    }

    public int getWidth() {

        return this.image.getWidth();

    }

    public int getHeight() {

        return this.image.getHeight();

    }

    public DefaultSimpleImage resize(double factor) {

        BufferedImage theImage = this.getBufferedImage();

        int w = theImage.getWidth();

        int h = theImage.getHeight();

        int width = (int) (w * factor);

        int height = (int) (h * factor);

        BufferedImage newImage = new BufferedImage(width, height, theImage.getType());

        Graphics2D g = newImage.createGraphics();

        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        g.drawImage(theImage, 0, 0, width, height, 0, 0, w, h, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage resize(int width, int height) {

        BufferedImage theImage = this.getBufferedImage();

        int w = theImage.getWidth();

        int h = theImage.getHeight();

        BufferedImage newImage = new BufferedImage(width, height, theImage.getType());

        Graphics2D g = newImage.createGraphics();

        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        g.drawImage(theImage, 0, 0, width, height, 0, 0, w, h, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage rotate(int angle) {

        BufferedImage theImage = this.getBufferedImage();

        int w = theImage.getWidth();

        int h = theImage.getHeight();

        BufferedImage newImage = new BufferedImage(w, h, theImage.getType());

        Graphics2D g = newImage.createGraphics();

        g.rotate(Math.toRadians(angle), w / 2, h / 2);

        g.drawImage(theImage, null, 0, 0);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage horizontalflip() {

        BufferedImage img = this.getBufferedImage();

        int w = img.getWidth();

        int h = img.getHeight();

        BufferedImage newImage = new BufferedImage(w, h, img.getType());

        Graphics2D g = newImage.createGraphics();

        g.drawImage(img, 0, 0, w, h, w, 0, 0, h, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage verticalflip() {

        BufferedImage img = this.getBufferedImage();

        int w = img.getWidth();

        int h = img.getHeight();

        BufferedImage newImage = new BufferedImage(w, h, img.getColorModel().getTransparency());

        Graphics2D g = newImage.createGraphics();

        g.drawImage(img, 0, 0, w, h, 0, h, w, 0, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage transform(AffineTransform transform, int width, int height) {

        BufferedImage img = this.getBufferedImage();

        BufferedImage newImage = new BufferedImage(width, height, img.getColorModel().getTransparency());

        Graphics2D g = newImage.createGraphics();

        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        g.setTransform(transform);

        g.drawImage(img, 0, 0, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    public DefaultSimpleImage transform(AffineTransform transform) {

        BufferedImage img = this.getBufferedImage();

        int w = img.getWidth();

        int h = img.getHeight();

        BufferedImage newImage = new BufferedImage(w, h, img.getColorModel().getTransparency());

        Graphics2D g = newImage.createGraphics();

        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

        g.setTransform(transform);

        g.drawImage(img, 0, 0, null);

        g.dispose();

        return new DefaultSimpleImage(newImage);

    }

    private String bytearray_hex(byte[] data) {

        StringBuilder builder = new StringBuilder();

        for (byte abyte : data) {

            int v = abyte & 0xff;

            builder.append(String.format("%02x", v));

        }

        return builder.toString();

    }

    @Override

    public byte[] toBytearray() {

        try {

            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ImageIO.write( this.image, "png", baos );

            baos.flush();

            byte[] imageInByte = baos.toByteArray();        

            baos.close();

            return imageInByte;

        } catch (IOException ex) {

            return null;

        }

    }

    @Override

    public String toString() {

        byte[] data = this.toBytearray();

        return bytearray_hex(data);

    }

}