com.el.ecom.utils.ImageUtils.java Source code

Java tutorial

Introduction

Here is the source code for com.el.ecom.utils.ImageUtils.java

Source

/*
 * Copyright 2005-2014 shopxx.net. All rights reserved.
 * Support: http://www.shopxx.net
 * License: http://www.shopxx.net/license
 */
package com.el.ecom.utils;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageOutputStream;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.im4java.core.CompositeCmd;
import org.im4java.core.ConvertCmd;
import org.im4java.core.IM4JavaException;
import org.im4java.core.IMOperation;
import org.im4java.core.IdentifyCmd;
import org.springframework.util.Assert;

import com.el.ecom.utils.Setting.WatermarkPosition;

/**
 * Utils - ?(?JDK?GraphicsMagick?ImageMagick)]
 * 
 */
public final class ImageUtils {

    /**
     * ?
     */
    private enum Type {

        /**  */
        auto,

        /** jdk */
        jdk,

        /**
         * GraphicsMagick
         */
        graphicsMagick,

        /**
         * ImageMagick
         */
        imageMagick
    }

    /** ? */
    private static Type type = Type.auto;

    /** GraphicsMagick? */
    private static String graphicsMagickPath;

    /** ImageMagick? */
    private static String imageMagickPath;

    /**  */
    private static final Color BACKGROUND_COLOR = Color.white;

    /** ?(?: 0 - 100) */
    private static final int DEST_QUALITY = 88;

    static {
        if (graphicsMagickPath == null) {
            String osName = System.getProperty("os.name").toLowerCase();
            if (osName.indexOf("windows") >= 0) {
                String pathVariable = System.getenv("Path");
                if (pathVariable != null) {
                    String[] paths = StringUtils.split(pathVariable, ";");
                    for (String path : paths) {
                        File gmFile = new File(path.trim() + "/gm.exe");
                        File gmdisplayFile = new File(path.trim() + "/gmdisplay.exe");
                        if (gmFile.exists() && gmdisplayFile.exists()) {
                            graphicsMagickPath = path.trim();
                            break;
                        }
                    }
                }
            }
        }

        if (imageMagickPath == null) {
            String osName = System.getProperty("os.name").toLowerCase();
            if (osName.indexOf("windows") >= 0) {
                String pathVariable = System.getenv("Path");
                if (pathVariable != null) {
                    String[] paths = StringUtils.split(pathVariable, ";");
                    for (String path : paths) {
                        File convertFile = new File(path.trim() + "/convert.exe");
                        File compositeFile = new File(path.trim() + "/composite.exe");
                        if (convertFile.exists() && compositeFile.exists()) {
                            imageMagickPath = path.trim();
                            break;
                        }
                    }
                }
            }
        }

        if (type == Type.auto) {
            try {
                IMOperation operation = new IMOperation();
                operation.version();
                IdentifyCmd identifyCmd = new IdentifyCmd(true);
                if (graphicsMagickPath != null) {
                    identifyCmd.setSearchPath(graphicsMagickPath);
                }
                identifyCmd.run(operation);
                type = Type.graphicsMagick;
            } catch (Throwable e1) {
                try {
                    IMOperation operation = new IMOperation();
                    operation.version();
                    IdentifyCmd identifyCmd = new IdentifyCmd(false);
                    identifyCmd.run(operation);
                    if (imageMagickPath != null) {
                        identifyCmd.setSearchPath(imageMagickPath);
                    }
                    type = Type.imageMagick;
                } catch (Throwable e2) {
                    type = Type.jdk;
                }
            }
        }
    }

    /**
     * ??
     */
    private ImageUtils() {
    }

    /**
     * 
     * 
     * @param srcFile ?
     * @param destFile 
     * @param destWidth 
     * @param destHeight 
     */
    public static void zoom(File srcFile, File destFile, int destWidth, int destHeight) {
        Assert.notNull(srcFile);
        Assert.state(srcFile.exists());
        Assert.state(srcFile.isFile());
        Assert.notNull(destFile);
        Assert.state(destWidth > 0);
        Assert.state(destHeight > 0);

        if (type == Type.jdk) {
            Graphics2D graphics2D = null;
            ImageOutputStream imageOutputStream = null;
            ImageWriter imageWriter = null;
            try {
                BufferedImage srcBufferedImage = ImageIO.read(srcFile);
                int srcWidth = srcBufferedImage.getWidth();
                int srcHeight = srcBufferedImage.getHeight();
                int width = destWidth;
                int height = destHeight;
                if (srcHeight >= srcWidth) {
                    width = (int) Math.round(((destHeight * 1.0 / srcHeight) * srcWidth));
                } else {
                    height = (int) Math.round(((destWidth * 1.0 / srcWidth) * srcHeight));
                }
                BufferedImage destBufferedImage = new BufferedImage(destWidth, destHeight,
                        BufferedImage.TYPE_INT_RGB);
                graphics2D = destBufferedImage.createGraphics();
                graphics2D.setBackground(BACKGROUND_COLOR);
                graphics2D.clearRect(0, 0, destWidth, destHeight);
                graphics2D.drawImage(srcBufferedImage.getScaledInstance(width, height, Image.SCALE_SMOOTH),
                        (destWidth / 2) - (width / 2), (destHeight / 2) - (height / 2), null);

                imageOutputStream = ImageIO.createImageOutputStream(destFile);
                imageWriter = ImageIO.getImageWritersByFormatName(FilenameUtils.getExtension(destFile.getName()))
                        .next();
                imageWriter.setOutput(imageOutputStream);
                ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam();
                imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                imageWriteParam.setCompressionQuality((float) (DEST_QUALITY / 100.0));
                imageWriter.write(null, new IIOImage(destBufferedImage, null, null), imageWriteParam);
                imageOutputStream.flush();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(), e);
            } finally {
                if (graphics2D != null) {
                    graphics2D.dispose();
                }
                if (imageWriter != null) {
                    imageWriter.dispose();
                }
                try {
                    if (imageOutputStream != null) {
                        imageOutputStream.close();
                    }
                } catch (IOException e) {
                }
            }
        } else {
            IMOperation operation = new IMOperation();
            operation.thumbnail(destWidth, destHeight);
            operation.gravity("center");
            operation.background(toHexEncoding(BACKGROUND_COLOR));
            operation.extent(destWidth, destHeight);
            operation.quality((double) DEST_QUALITY);
            try {
                operation.addImage(srcFile.getCanonicalPath());
                operation.addImage(destFile.getCanonicalPath());
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
            if (type == Type.graphicsMagick) {
                ConvertCmd convertCmd = new ConvertCmd(true);
                if (graphicsMagickPath != null) {
                    convertCmd.setSearchPath(graphicsMagickPath);
                }
                try {
                    convertCmd.run(operation);
                } catch (IOException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (IM4JavaException e) {
                    throw new RuntimeException(e.getMessage(), e);
                }
            } else {
                ConvertCmd convertCmd = new ConvertCmd(false);
                if (imageMagickPath != null) {
                    convertCmd.setSearchPath(imageMagickPath);
                }
                try {
                    convertCmd.run(operation);
                } catch (IOException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (IM4JavaException e) {
                    throw new RuntimeException(e.getMessage(), e);
                }
            }
        }
    }

    /**
     * ?
     * 
     * @param srcFile ?
     * @param destFile 
     * @param watermarkFile ?
     * @param watermarkPosition ??
     * @param alpha ??
     */
    public static void addWatermark(File srcFile, File destFile, File watermarkFile,
            WatermarkPosition watermarkPosition, int alpha) {
        Assert.notNull(srcFile);
        Assert.state(srcFile.exists());
        Assert.state(srcFile.isFile());
        Assert.notNull(destFile);
        Assert.state(alpha >= 0);
        Assert.state(alpha <= 100);

        if (watermarkFile == null || !watermarkFile.exists() || !watermarkFile.isFile() || watermarkPosition == null
                || watermarkPosition == WatermarkPosition.no) {
            try {
                if (!StringUtils.equals(srcFile.getCanonicalPath(), destFile.getCanonicalPath())) {
                    FileUtils.copyFile(srcFile, destFile);
                }
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
            return;
        }
        if (type == Type.jdk) {
            Graphics2D graphics2D = null;
            ImageOutputStream imageOutputStream = null;
            ImageWriter imageWriter = null;
            try {
                BufferedImage srcBufferedImage = ImageIO.read(srcFile);
                int srcWidth = srcBufferedImage.getWidth();
                int srcHeight = srcBufferedImage.getHeight();
                BufferedImage destBufferedImage = new BufferedImage(srcWidth, srcHeight,
                        BufferedImage.TYPE_INT_RGB);
                graphics2D = destBufferedImage.createGraphics();
                graphics2D.setBackground(BACKGROUND_COLOR);
                graphics2D.clearRect(0, 0, srcWidth, srcHeight);
                graphics2D.drawImage(srcBufferedImage, 0, 0, null);
                graphics2D.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha / 100F));

                BufferedImage watermarkBufferedImage = ImageIO.read(watermarkFile);
                int watermarkImageWidth = watermarkBufferedImage.getWidth();
                int watermarkImageHeight = watermarkBufferedImage.getHeight();
                int x = srcWidth - watermarkImageWidth;
                int y = srcHeight - watermarkImageHeight;
                if (watermarkPosition == WatermarkPosition.topLeft) {
                    x = 0;
                    y = 0;
                } else if (watermarkPosition == WatermarkPosition.topRight) {
                    x = srcWidth - watermarkImageWidth;
                    y = 0;
                } else if (watermarkPosition == WatermarkPosition.center) {
                    x = (srcWidth - watermarkImageWidth) / 2;
                    y = (srcHeight - watermarkImageHeight) / 2;
                } else if (watermarkPosition == WatermarkPosition.bottomLeft) {
                    x = 0;
                    y = srcHeight - watermarkImageHeight;
                } else if (watermarkPosition == WatermarkPosition.bottomRight) {
                    x = srcWidth - watermarkImageWidth;
                    y = srcHeight - watermarkImageHeight;
                }
                graphics2D.drawImage(watermarkBufferedImage, x, y, watermarkImageWidth, watermarkImageHeight, null);

                imageOutputStream = ImageIO.createImageOutputStream(destFile);
                imageWriter = ImageIO.getImageWritersByFormatName(FilenameUtils.getExtension(destFile.getName()))
                        .next();
                imageWriter.setOutput(imageOutputStream);
                ImageWriteParam imageWriteParam = imageWriter.getDefaultWriteParam();
                imageWriteParam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
                imageWriteParam.setCompressionQuality(DEST_QUALITY / 100F);
                imageWriter.write(null, new IIOImage(destBufferedImage, null, null), imageWriteParam);
                imageOutputStream.flush();
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(), e);
            } finally {
                if (graphics2D != null) {
                    graphics2D.dispose();
                }
                if (imageWriter != null) {
                    imageWriter.dispose();
                }
                try {
                    if (imageOutputStream != null) {
                        imageOutputStream.close();
                    }
                } catch (IOException e) {
                }
            }
        } else {
            String gravity = "SouthEast";
            if (watermarkPosition == WatermarkPosition.topLeft) {
                gravity = "NorthWest";
            } else if (watermarkPosition == WatermarkPosition.topRight) {
                gravity = "NorthEast";
            } else if (watermarkPosition == WatermarkPosition.center) {
                gravity = "Center";
            } else if (watermarkPosition == WatermarkPosition.bottomLeft) {
                gravity = "SouthWest";
            } else if (watermarkPosition == WatermarkPosition.bottomRight) {
                gravity = "SouthEast";
            }
            IMOperation operation = new IMOperation();
            operation.gravity(gravity);
            operation.dissolve(alpha);
            operation.quality((double) DEST_QUALITY);
            try {
                operation.addImage(watermarkFile.getCanonicalPath());
                operation.addImage(srcFile.getCanonicalPath());
                operation.addImage(destFile.getCanonicalPath());
            } catch (IOException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
            if (type == Type.graphicsMagick) {
                CompositeCmd compositeCmd = new CompositeCmd(true);
                if (graphicsMagickPath != null) {
                    compositeCmd.setSearchPath(graphicsMagickPath);
                }
                try {
                    compositeCmd.run(operation);
                } catch (IOException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (IM4JavaException e) {
                    throw new RuntimeException(e.getMessage(), e);
                }
            } else {
                CompositeCmd compositeCmd = new CompositeCmd(false);
                if (imageMagickPath != null) {
                    compositeCmd.setSearchPath(imageMagickPath);
                }
                try {
                    compositeCmd.run(operation);
                } catch (IOException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e.getMessage(), e);
                } catch (IM4JavaException e) {
                    throw new RuntimeException(e.getMessage(), e);
                }
            }
        }
    }

    /**
     * ?
     */
    public static void initialize() {
    }

    /**
     * ????
     * 
     * @param color 
     * @return ???
     */
    private static String toHexEncoding(Color color) {
        Assert.notNull(color);

        String R, G, B;
        StringBuilder result = new StringBuilder();
        R = Integer.toHexString(color.getRed());
        G = Integer.toHexString(color.getGreen());
        B = Integer.toHexString(color.getBlue());
        R = R.length() == 1 ? "0" + R : R;
        G = G.length() == 1 ? "0" + G : G;
        B = B.length() == 1 ? "0" + B : B;
        result.append("#").append(R).append(G).append(B);
        return result.toString();
    }

}