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

package org.gvsig.tools.swing.impl;

import java.awt.Dimension;

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.io.OutputStream;

import java.net.URL;

import java.util.Iterator;

import javax.imageio.ImageIO;

import javax.imageio.ImageReader;

import javax.imageio.stream.ImageInputStream;

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.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.NotImplementedException;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.mutable.MutableObject;

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

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultSimpleImage implements SimpleImage {

    private BufferedImage image;

    private Object source;

    private Dimension dimensions;

    private String formatName;

    public static BufferedImage toBufferedImage(Image img) {

        if( img == null ) {

          throw new IllegalArgumentException("null image.");

        }

        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() {

        this.image = null;

        this.dimensions = null;

        this.source = null;

        this.formatName = null;

    }

    private DefaultSimpleImage(BufferedImage image, DefaultSimpleImage other) {

        this();

        this.image = image;

        this.source = other.source;

        this.formatName = other.formatName;

    }

    public DefaultSimpleImage(BufferedImage image) {

        this();

        this.image = image;

        this.source = image;

    }

    public DefaultSimpleImage(Object source) {

        this();

        this.source = source;

    }

    public void clean() {

        this.image = null;

        this.dimensions = null;

        this.source = null;

        this.formatName = null;

    }

    @Override

    public BufferedImage getBufferedImage() {

        if( this.image == null ) {

          if( this.source!=null ) {

            Dimension dim = new Dimension();

            MutableObject<String> theFormatName = new MutableObject<>(null);

            this.image = this.load(source, dim, theFormatName);

            this.dimensions = dim;

            this.formatName = theFormatName.getValue();

          }

        }

        return this.image;

    }

    public BufferedImage getBufferedImage(int page) {

        if(page == 0){

            return getBufferedImage();

        }

        throw new NotImplementedException("Can't support multipage images");

    }

    public int getCountPages() {

        return 1;

    }

    @Override

    public String getFormatName() {

        return this.formatName;

    }

    @Override

    public boolean isEmpty() {

        return this.image == null && this.source==null ;

    }

    @Override

    public void set(BufferedImage image) {

        this.image = image;

        this.source = image;

    }

    @Override

    public void set(Object source) {

        this.image = null;

        this.source = source;

    }

    private BufferedImage load(Object source, Dimension dimensions, MutableObject<String> formatName) {

        BufferedImage theImage = null;

        if( formatName!=null ) {

            formatName.setValue(null);

        }

        try {

            if (source instanceof BufferedImage) {

                theImage = (BufferedImage) source;

            } else if (source instanceof ImageIcon ) {

                ImageIcon icon = (ImageIcon)source;

                int loadStatus = icon.getImageLoadStatus();

                if( loadStatus != MediaTracker.COMPLETE ) {

                    icon.getDescription();

                }

                theImage = toBufferedImage(icon.getImage());

            } else if (source instanceof Image) {

                theImage = toBufferedImage((Image) source);

            } else if (source instanceof byte[]) {

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

                theImage = ImageIO.read(is);

                if( formatName!=null ) {

                    formatName.setValue(this.getFormatName(source));

                }

            } else if (source instanceof File) {

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

                if( formatName!=null ) {

                    formatName.setValue(this.getFormatName(source));

                }

            } else if (source instanceof URL) {

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

                if( formatName!=null ) {

                    formatName.setValue(this.getFormatName(source));

                }

            } else if (source instanceof String) {

                InputStream is;

                String s = (String) source;

                File f = new File(s);

                byte[] data = null;

                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 {

                            data = Hex.decodeHex(s.toCharArray());

                            is = new ByteArrayInputStream(data);

                        } catch (DecoderException ex2) {

                            try {

                                data = Base64.decodeBase64(s);

                                is = new ByteArrayInputStream(data);

                            } catch (Exception ex3) {

                                return null;

                            }

                        }

                    }

                }

                theImage = ImageIO.read(is);

                IOUtils.closeQuietly(is);

                if( formatName!=null && data!=null ) {

                    formatName.setValue(this.getFormatName(data));

                }

            }

        } catch (IOException ex) {

            return null;

        }

        if( theImage!=null && dimensions!=null ) {

          dimensions.width = theImage.getWidth();

          dimensions.height = theImage.getHeight();

        }

        return theImage;

    }

    private String getFormatName(Object source) {

      try {

        ImageInputStream in = ImageIO.createImageInputStream(source);

        if (in==null) {

            return null;

        }

        Iterator<ImageReader> readers = ImageIO.getImageReaders(in);

        if (readers!=null && readers.hasNext()) {

          ImageReader reader = readers.next();

          try {

            reader.setInput(in);

            return reader.getFormatName();

          } finally {

            reader.dispose();

          }

        }

        return null;

      } catch (Exception ex) {

        throw new RuntimeException("Can't determine format name of the image.", ex);

      }

    }

    private Dimension loadDimensions(Object source) {

      try {

        ImageInputStream in = ImageIO.createImageInputStream(source);

        Iterator<ImageReader> readers = ImageIO.getImageReaders(in);

        if (readers!=null && readers.hasNext()) {

          ImageReader reader = readers.next();

          try {

            reader.setInput(in);

            return new Dimension(reader.getWidth(0), reader.getHeight(0));

          } finally {

            reader.dispose();

          }

        }

        Dimension dim = new Dimension();

        this.image = this.load(source, dim, null);

        return dim;

      } catch (IOException ex) {

        throw new RuntimeException("Can't load dimensions of the image.", ex);

      }

    }

    @Override

    public int getWidth() {

      if( this.dimensions == null ) {

        this.dimensions = this.loadDimensions(source);

      }

      return this.dimensions.width;

    }

    @Override

    public int getHeight() {

      if( this.dimensions == null ) {

        this.dimensions = this.loadDimensions(source);

      }

      return this.dimensions.height;

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    @Override

    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, this);

    }

    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() {

        return toBytearray(null);

    }

    @Override

    public byte[] toBytearray(String format) {

        try {

            if( this.getBufferedImage()==null ) {

                return null;

            }

            if( StringUtils.isBlank(format) ) {

                format = this.formatName==null?"png":this.formatName;

            }

            ByteArrayOutputStream baos = new ByteArrayOutputStream();

            ImageIO.write( this.getBufferedImage(), format, 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);

    }

    @Override

    public String toString(String format) {

        byte[] data = this.toBytearray(format);

        return bytearray_hex(data);

    }

    @Override

    public void save(File output, String formatName) throws IOException {

        if( StringUtils.isBlank(formatName) ) {

            formatName = this.formatName==null?"png":this.formatName;

        }

        ImageIO.write(this.getBufferedImage(), formatName, output);

    }

    @Override

    public void save(OutputStream output, String formatName) throws IOException {

        if( StringUtils.isBlank(formatName) ) {

            formatName = this.formatName==null?"png":this.formatName;

        }

        ImageIO.write(this.getBufferedImage(), formatName, output);

    }

    @Override

    public boolean equals(Object obj) {

        if( !(obj instanceof SimpleImage) ) {

            return false;

        }

        SimpleImage other = (SimpleImage) obj;

        return this.hashCode() == other.hashCode();

    }

    @Override

    public int hashCode() {

        if( this.isEmpty() ) {

            return 0;

        }

        byte[] bytes = this.toBytearray();        

        int hash = ArrayUtils.hashCode(bytes);

        return hash;

    }

}