image 和 imagebuffer 的 使用 （一个图片 处理 的 算法 ）

package com.max.msp.image.impl;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.File;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Map.Entry;

import javax.imageio.ImageIO;

import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpState;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.max.msp.image.ImageInfo;
import com.max.msp.image.ImageProcessor;
import com.max.msp.image.impl.ImageInfoManager.ImageDetailInfo;
import com.max.msp.utils.CookiesHolder;

/**
 *
 * @author quanyong.zhao
 *
 */
public class SyncImageProcessor implements ImageProcessor {

    private static Log LOG = LogFactory.getLog(SyncImageProcessor.class);

    private ImageInfoManager imageInfoManager;

    private Dimension maxImageSize = new Dimension(160, 200);

    private int timeout = 30 * 1000; // 30秒

    public ImageInfo createImage(String srcImageUrl) throws Exception {
        return createImage(srcImageUrl, maxImageSize, null);
    }

    public ImageInfo createImage(String srcImageUrl, CookiesHolder cookiesHolder)
            throws Exception {
        return createImage(srcImageUrl, new Dimension[] { maxImageSize }, null,
                cookiesHolder)[0];
    }

    public ImageInfo createImage(String srcImageUrl, Properties properties)
            throws Exception {
        return createImage(srcImageUrl, maxImageSize, properties);
    }

    public ImageInfo createImage(String srcImageUrl, Dimension imageMaxSize)
            throws Exception {
        return createImage(srcImageUrl, imageMaxSize, null);
    }

    public ImageInfo[] createImage(String srcImageUrl, Dimension[] imageMaxSizes)
            throws Exception {
        if (LOG.isDebugEnabled()) {
            LOG.debug("url==============[" + srcImageUrl + "]");
            LOG.debug("Dimension================[" + imageMaxSizes + "]");
        }
        return createImage(srcImageUrl, imageMaxSizes, null);
    }

    public ImageInfo createImage(String srcImageUrl, Dimension imageMaxSize,
            Properties properties) throws Exception {
        return createImage(srcImageUrl, new Dimension[] { imageMaxSize },
                properties)[0];
    }

    public ImageInfo[] createImage(String srcImageUrl,
            Dimension[] imageMaxSizes, Properties properties) throws Exception {
        return createImage(srcImageUrl, imageMaxSizes, properties, null);
    }

    public ImageInfo[] createImage(String srcImageUrl,
            Dimension[] imageMaxSizes, Properties properties,
            CookiesHolder cookiesHolder) throws Exception {
        BufferedImage srcImage = null;
        ImageDetailInfo[] iamgeDetailInfos = new ImageDetailInfo[imageMaxSizes.length];

        String subPath = getSubPath(srcImageUrl);

        for (int i = 0; i < imageMaxSizes.length; i++) {
            Dimension imageMaxSize = imageMaxSizes[i];
            String filename = getFilename(srcImageUrl, imageMaxSize);

            File file = new File(imageInfoManager.getRootPath() + subPath
                    + filename);
            String dstImageUrl = imageInfoManager.getRootUrl()
                    + subPath.replace(File.separatorChar, '/') + filename;

            ImageDetailInfo imageDetailInfo = imageInfoManager
                    .getImageInfo(file.getPath());
            if (imageDetailInfo != null) {
                imageDetailInfo
                        .setCreateTime((int) (new Date().getTime() / 1000));
                if (LOG.isDebugEnabled()) {
                    LOG.debug(srcImageUrl + " <----> " + file.getPath()
                            + " <----> " + dstImageUrl
                            + " is updated the create time");
                }
                iamgeDetailInfos[i] = imageDetailInfo;
                continue;
            }
            if (srcImage == null) {
                srcImage = this.getSrcImage(srcImageUrl, properties,
                        cookiesHolder);
            }

            BufferedImage image = scaleImage(srcImage, imageMaxSize);

            File pathFile = new File(imageInfoManager.getRootPath() + subPath);
            if (!pathFile.exists() || !pathFile.isDirectory()) {
                pathFile.mkdirs();
            }
            ImageIO.write(image, "png", file);
            imageDetailInfo = new ImageDetailInfo();
            imageDetailInfo.setUrl(dstImageUrl);
            imageDetailInfo.setWidth(image.getWidth());
            imageDetailInfo.setHeight(image.getHeight());
            imageInfoManager.putImageInfo(file.getPath(), imageDetailInfo);
            if (LOG.isDebugEnabled()) {
                LOG.debug(srcImageUrl + " <----> " + file.getPath()
                        + " <----> " + dstImageUrl + " is created");
            }
            iamgeDetailInfos[i] = imageDetailInfo;
        }
        return iamgeDetailInfos;
    }

    public void deleteImage(String srcImageUrl) {
        String prefix = String.valueOf(Math.abs(srcImageUrl.hashCode())) + "_";
        String subPath = getSubPath(srcImageUrl);
        File path = new File(imageInfoManager.getRootPath() + subPath);
        if (path.exists()) {
            String[] filenames = path.list();
            for (String filename : filenames) {
                if (filename.startsWith(prefix)) {
                    File file = new File(imageInfoManager.getRootPath()
                            + subPath + filename);
                    if (!file.delete()) {
                        LOG.error(file.getPath() + " cann't been deleted");
                    } else {
                        if (LOG.isDebugEnabled()) {
                            LOG.debug(file.getPath() + " is deleted");
                        }
                    }
                }
            }
        }
    }

    /**
     *
     * @param srcImageUrl
     * @param properties
     * @return
     * @throws Exception
     */

    protected BufferedImage getSrcImage(String srcImageUrl,
            Properties properties, CookiesHolder cookiesHolder)
            throws Exception {
        GetMethod getMethod = new GetMethod(srcImageUrl);
        try {
            getMethod.getParams().setParameter("http.socket.timeout",
                    new Integer(timeout));

            if (properties != null) {
                Iterator<Entry<Object, Object>> it = properties.entrySet()
                        .iterator();
                while (it.hasNext()) {
                    Entry<Object, Object> entry = it.next();
                    getMethod.setRequestHeader(entry.getKey().toString(), entry
                            .getValue().toString());
                }
            }
            HttpClient httpClient = new HttpClient();
            if (cookiesHolder != null) {
                HttpState initialState = new HttpState();
                Cookie[] cookies = cookiesHolder.getCookies();
                if (cookies != null && cookies.length != 0) {
                    initialState.addCookies(cookies);
                    if (LOG.isDebugEnabled()) {
                        for (Cookie cookie : cookies) {
                            LOG.debug(cookie.toString());
                        }
                    }
                }
                httpClient.setState(initialState);
            }

            int resultCode = httpClient.executeMethod(getMethod);
            if (resultCode != 200) {
                throw new HttpException("http post method return " + resultCode);
            }
            if (cookiesHolder != null) {
                cookiesHolder.setCookies(httpClient.getState().getCookies());
            }
            return ImageIO.read(getMethod.getResponseBodyAsStream());
        } finally {
            getMethod.releaseConnection();
        }
    }

    /**
     * 缩小图片。如果图片大小小于maxImageSize，将不处理图片
     *
     * @param srcImage
     * @param imageMaxSize
     * @return
     */
    protected BufferedImage scaleImage(BufferedImage srcImage,
            Dimension maxImageSize) {
        double xscale = (double) maxImageSize.width / srcImage.getWidth();
        double yscale = (double) maxImageSize.height / srcImage.getHeight();
        if (xscale < yscale) {
            yscale = xscale;
        } else {
            xscale = yscale;
        }

        if (xscale > 1) {
            BufferedImage dstImage = new BufferedImage(srcImage.getWidth(),
                    srcImage.getHeight(), BufferedImage.TRANSLUCENT);
            dstImage.getGraphics().drawImage(srcImage, 0, 0,
                    srcImage.getWidth(), srcImage.getHeight(), null);
            return dstImage;
        }

        int width = (int) (srcImage.getWidth() * xscale);
        int height = (int) (srcImage.getHeight() * yscale);
        BufferedImage dstImage = new BufferedImage(width, height,
                BufferedImage.TRANSLUCENT);
        dstImage.getGraphics().drawImage(srcImage, 0, 0, width, height, null);

        return dstImage;
    }

    /**
     *
     * @param srcImage
     * @param imageSize
     * @return
     */
    protected BufferedImage cutAndScaleImage(BufferedImage srcImage,
            Dimension imageSize) {
        double xscale = (double) imageSize.width / srcImage.getWidth();
        double yscale = (double) imageSize.height / srcImage.getHeight();
        if (xscale > 1 && yscale > 1) {
            BufferedImage dstImage = new BufferedImage(srcImage.getWidth(),
                    srcImage.getHeight(), srcImage.getType() == 0 ? 1
                            : srcImage.getType());
            dstImage.getGraphics().drawImage(srcImage, 0, 0,
                    srcImage.getWidth(), srcImage.getHeight(), null);
            return dstImage;
        }
        int x1 = 0;
        int y1 = 0;
        int x2 = srcImage.getWidth();
        int y2 = srcImage.getHeight();
        if (xscale < yscale) {
            int width = (srcImage.getHeight() * imageSize.width)
                    / imageSize.height;
            x1 = (srcImage.getWidth() - width) / 2;
            x2 = width + x1;
        } else {
            int height = (srcImage.getWidth() * imageSize.height)
                    / imageSize.width;
            y1 = (srcImage.getHeight() - height) / 2;
            y2 = height + y1;
        }

        BufferedImage dstImage = new BufferedImage(imageSize.width,
                imageSize.height, srcImage.getType() == 0 ? 1 : srcImage
                        .getType());
        dstImage.getGraphics().drawImage(srcImage, 0, 0, imageSize.width,
                imageSize.height, x1, y1, x2, y2, null);
        return dstImage;
    }

    protected BufferedImage scaleImage(BufferedImage srcImage, int width) {
        double scale = (double) width / srcImage.getWidth();
        if (scale > 1) {
            BufferedImage dstImage = new BufferedImage(srcImage.getWidth(),
                    srcImage.getHeight(), srcImage.getType() == 0 ? 1
                            : srcImage.getType());
            dstImage.getGraphics().drawImage(srcImage, 0, 0,
                    srcImage.getWidth(), srcImage.getHeight(), null);
            return dstImage;
        }

        int height = (int) (srcImage.getHeight() * scale);
        BufferedImage dstImage = new BufferedImage(width, height, srcImage
                .getType() == 0 ? 1 : srcImage.getType());
        dstImage.getGraphics().drawImage(srcImage, 0, 0, width, height, null);
        return dstImage;
    }

    protected String getSubPath(String srcImageUrl) {
        StringBuffer buffer = new StringBuffer();
        int length = srcImageUrl.length() / 5;
        for (int i = 0; i < 5; i++) {
            String path = srcImageUrl.substring(i * length, (i + 1) * length);
            int ch = Math.abs(path.hashCode()) % 52;
            if (ch < 26) {
                ch += 'a';
            } else {
                ch += ('A' - 26);
            }
            buffer.append((char) ch);
            buffer.append(File.separator);
        }
        return buffer.toString();
    }

    protected String getFilename(String srcImageUrl, Dimension imageMaxSize) {
        return Math.abs(srcImageUrl.hashCode()) + "_" + imageMaxSize.width
                + "x" + imageMaxSize.height + ".png";
    }

    protected String getFilename(String srcImageUrl, int width) {
        return Math.abs(srcImageUrl.hashCode()) + "_" + width + ".png";
    }

    public int getTimeout() {
        return timeout;
    }

    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    public Dimension getMaxImageSize() {
        return maxImageSize;
    }

    public void setMaxImageSize(Dimension maxImageSize) {
        this.maxImageSize = maxImageSize;
    }

    public ImageInfoManager getImageInfoManager() {
        return imageInfoManager;
    }

    public void setImageInfoManager(ImageInfoManager imageInfoManager) {
        this.imageInfoManager = imageInfoManager;
    }

    public ImageInfo mergerHImage(String[] srcImageUrls, Dimension imageMaxSize)
            throws Exception {
        StringBuffer buffer = new StringBuffer();
        for (String tmp : srcImageUrls) {
            buffer.append(tmp).append(';');
        }

        String subPath = getSubPath(buffer.toString());

        String filename = getFilename(buffer.toString(), imageMaxSize);

        File file = new File(imageInfoManager.getRootPath() + subPath
                + filename);
        String dstImageUrl = imageInfoManager.getRootUrl()
                + subPath.replace(File.separatorChar, '/') + filename;

        ImageDetailInfo imageDetailInfo = imageInfoManager.getImageInfo(file
                .getPath());
        if (imageDetailInfo != null) {
            imageDetailInfo.setCreateTime((int) (new Date().getTime() / 1000));
            if (LOG.isDebugEnabled()) {
                LOG.debug(buffer.toString() + " <----> " + file.getPath()
                        + " <----> " + dstImageUrl
                        + " is updated the create time");
            }
            return imageDetailInfo;
        }

        List<BufferedImage> srcImages = new ArrayList<BufferedImage>();
        int width = 0;
        int height = 0;
        for (String srcImageUrl : srcImageUrls) {
            BufferedImage srcImage = this.getSrcImage(srcImageUrl, null, null);
            if (srcImage != null) {
                srcImages.add(srcImage);
                width += srcImage.getWidth();
                height = Math.max(height, srcImage.getHeight());
            }
        }
        BufferedImage dstImage = new BufferedImage(width, height,
                BufferedImage.TRANSLUCENT);
        int x = 0;
        for (BufferedImage srcImage : srcImages) {
            dstImage.getGraphics().drawImage(srcImage, x, 0,
                    srcImage.getWidth(), srcImage.getHeight(), null);
            x += srcImage.getWidth();
        }

        BufferedImage image = scaleImage(dstImage, imageMaxSize);

        File pathFile = new File(imageInfoManager.getRootPath() + subPath);
        if (!pathFile.exists() || !pathFile.isDirectory()) {
            pathFile.mkdirs();
        }
        ImageIO.write(image, "png", file);
        imageDetailInfo = new ImageDetailInfo();
        imageDetailInfo.setUrl(dstImageUrl);
        imageDetailInfo.setWidth(image.getWidth());
        imageDetailInfo.setHeight(image.getHeight());
        imageInfoManager.putImageInfo(file.getPath(), imageDetailInfo);
        if (LOG.isDebugEnabled()) {
            LOG.debug(buffer.toString() + " <----> " + file.getPath()
                    + " <----> " + dstImageUrl + " is created");
        }
        return imageDetailInfo;
    }

    public ImageInfo mergerHImage(String[] srcImageUrl) throws Exception {
        return mergerHImage(srcImageUrl, maxImageSize);
    }

    public ImageInfo createScreenImage(String srcImageUrl, int width)
            throws Exception {
        return createScreenImage(srcImageUrl, width, null);
    }

    public ImageInfo createScreenImage(String srcImageUrl, int width,
            Properties properties) throws Exception {
        return createScreenImage(srcImageUrl, new int[] { width }, properties)[0];
    }

    public ImageInfo[] createScreenImage(String srcImageUrl, int[] widths)
            throws Exception {
        return createScreenImage(srcImageUrl, widths, null);
    }

    public ImageInfo[] createScreenImage(String srcImageUrl, int[] widths,
            Properties properties) throws Exception {
        BufferedImage srcImage = null;
        ImageDetailInfo[] iamgeDetailInfos = new ImageDetailInfo[widths.length];
        String subPath = getSubPath(srcImageUrl);

        for (int i = 0; i < widths.length; i++) {
            int width = widths[i];
            String filename = getFilename(srcImageUrl, width);

            File file = new File(imageInfoManager.getRootPath() + subPath
                    + filename);
            String dstImageUrl = imageInfoManager.getRootUrl()
                    + subPath.replace(File.separatorChar, '/') + filename;

            ImageDetailInfo imageDetailInfo = imageInfoManager
                    .getImageInfo(file.getPath());
            if (imageDetailInfo != null) {
                imageDetailInfo
                        .setCreateTime((int) (new Date().getTime() / 1000));
                if (LOG.isDebugEnabled()) {
                    LOG.debug(srcImageUrl + " <----> " + file.getPath()
                            + " <----> " + dstImageUrl
                            + " is updated the create time");
                }
                iamgeDetailInfos[i] = imageDetailInfo;
                continue;
            }
            if (srcImage == null) {
                srcImage = this.getSrcImage(srcImageUrl, properties, null);
            }

            BufferedImage image = scaleImage(srcImage, width);

            File pathFile = new File(imageInfoManager.getRootPath() + subPath);
            if (!pathFile.exists() || !pathFile.isDirectory()) {
                pathFile.mkdirs();
            }
            ImageIO.write(image, "png", file);
            imageDetailInfo = new ImageDetailInfo();
            imageDetailInfo.setUrl(dstImageUrl);
            imageDetailInfo.setWidth(image.getWidth());
            imageDetailInfo.setHeight(image.getHeight());
            imageInfoManager.putImageInfo(file.getPath(), imageDetailInfo);
            if (LOG.isDebugEnabled()) {
                LOG.debug(srcImageUrl + " <----> " + file.getPath()
                        + " <----> " + dstImageUrl + " is created");
            }
            iamgeDetailInfos[i] = imageDetailInfo;
        }
        return iamgeDetailInfos;
    }

    public ImageInfo createBriefImage(String srcImageUrl, Dimension imageSize)
            throws Exception {
        return createBriefImage(srcImageUrl, imageSize, null);
    }

    public ImageInfo createBriefImage(String srcImageUrl, Dimension imageSize,
            Properties properties) throws Exception {
        return createBriefImage(srcImageUrl, new Dimension[] { imageSize },
                properties)[0];
    }

    public ImageInfo[] createBriefImage(String srcImageUrl,
            Dimension[] imageSizes) throws Exception {
        return createBriefImage(srcImageUrl, imageSizes, null);
    }

    public ImageInfo[] createBriefImage(String srcImageUrl,
            Dimension[] imageSizes, Properties properties) throws Exception {
        BufferedImage srcImage = null;
        ImageDetailInfo[] iamgeDetailInfos = new ImageDetailInfo[imageSizes.length];

        String subPath = getSubPath(srcImageUrl);

        for (int i = 0; i < imageSizes.length; i++) {
            Dimension imageSize = imageSizes[i];
            String filename = getFilename(srcImageUrl, imageSize);

            filename = "C" + filename;

            File file = new File(imageInfoManager.getRootPath() + subPath
                    + filename);
            String dstImageUrl = imageInfoManager.getRootUrl()
                    + subPath.replace(File.separatorChar, '/') + filename;

            ImageDetailInfo imageDetailInfo = imageInfoManager
                    .getImageInfo(file.getPath());
            if (imageDetailInfo != null) {
                imageDetailInfo
                        .setCreateTime((int) (new Date().getTime() / 1000));
                if (LOG.isDebugEnabled()) {
                    LOG.debug(srcImageUrl + " <----> " + file.getPath()
                            + " <----> " + dstImageUrl
                            + " is updated the create time");
                }
                iamgeDetailInfos[i] = imageDetailInfo;
                continue;
            }
            if (srcImage == null) {
                srcImage = this.getSrcImage(srcImageUrl, properties, null);
            }

            BufferedImage image = cutAndScaleImage(srcImage, imageSize);

            File pathFile = new File(imageInfoManager.getRootPath() + subPath);
            if (!pathFile.exists() || !pathFile.isDirectory()) {
                pathFile.mkdirs();
            }
            ImageIO.write(image, "png", file);
            imageDetailInfo = new ImageDetailInfo();
            imageDetailInfo.setUrl(dstImageUrl);
            imageDetailInfo.setWidth(image.getWidth());
            imageDetailInfo.setHeight(image.getHeight());
            imageInfoManager.putImageInfo(file.getPath(), imageDetailInfo);
            if (LOG.isDebugEnabled()) {
                LOG.debug(srcImageUrl + " <----> " + file.getPath()
                        + " <----> " + dstImageUrl + " is created");
            }
            iamgeDetailInfos[i] = imageDetailInfo;
        }
        return iamgeDetailInfos;
    }

}