IM4Java + GraphicsMagick 实现高清图片剪裁处理

简单介绍

GraphicsMagick是ImageMagick的一个分支，相对于ImageMagick而言，TA处理速度更快，消耗资源更少。GraphicsMagick 是一个用来读写、生成超过90种图像格式的工具集合，支持包括 TIFF, JPEG, JPEG-2000,PNG, PDF, PhotoCD, SVG, 和GIF 等图像格式。GraphicsMagick 是基于 ImageMagick 开发的。

im4java是ImageMagick的另一个Java开源接口。与JMagick不同之处在于im4java只是生成与ImageMagick相对应的命令行，然后将生成的命令行传至选中的IM-command（使用java.lang.ProcessBuilder.start()实现）来执行相应的操作。它支持大部分ImageMagick命令，可以针对不同组的图片多次复用同一个命令行。im4java也是能够高清压缩图片，而且它也特别强大，至少一些基本常见的业务都是可以完美实现的。

Cropper是一款使用简单且功能强大的图片剪裁jQuery插件。该图片剪裁插件支持图片放大缩小，支持鼠标滚轮操作，支持图片旋转，支持触摸屏设备，支持canvas，并且支持跨浏览器使用。

技术选型

ImageCropper + GraphicsMagick + im4java + SpringMVC

ImageCropper官网： http://fengyuanchen.github.io/cropper/
GraphicsMagick官网： http://www.graphicsmagick.org/
im4java下载: http://sourceforge.net/projects/im4java/files/?source=navbar

处理逻辑
1、前端进行图片剪裁，并展示剪裁后的效果图；
2、点击确定后，将参数(x，y坐标，长宽，旋转角度)传到后端，并将图片上传至服务器，在调用im4java api进行图片处理。
3、返回处理后的图片路径，前端展示。

编程实现

图片剪裁处理类

package org.hcm.utils;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.im4java.core.ConvertCmd;
import org.im4java.core.IM4JavaException;
import org.im4java.core.IMOperation;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;


public class ImageUtils {
    
    private static Log logger = LogFactory.getLog(ImageUtils.class);
    
    /**
     * 保存文件
     *
     * @param inputStream
     * @param path
     * @param fileName
     */
    public static void saveFileFromInputStream(InputStream inputStream, String path, String fileName) {
        File file = new File(path + fileName);
        FileOutputStream fs = null;
        try {
            fs = new FileOutputStream(file);
            byte[] buffer = new byte[1024 * 1024];
            int byteread = 0;
            while ((byteread = inputStream.read(buffer)) != -1) {
                fs.write(buffer, 0, byteread);
                fs.flush();
            }
        } catch (FileNotFoundException e) {
            logger.error("File Not Found !", e);
        } catch (IOException e) {
            logger.error("", e);
        } finally {
            try {
                if (fs != null) {
                    fs.close();
                }
                if (inputStream != null) {
                    inputStream.close();
                }
            } catch (IOException e) {
                logger.error("", e);
            }
        }
    }
    
    
    /**
     * 裁剪图片
     * 
     * @param imagePath
     *            源图片路径
     * @param newPath
     *            处理后图片路径
     * @param x
     *            起始X坐标
     * @param y
     *            起始Y坐标
     * @param width
     *            裁剪宽度
     * @param height
     *            裁剪高度
     * @return 返回true说明裁剪成功,否则失败
     */
    public static boolean cutImage(String imagePath, String newPath, int x, int y, int width, int height) {
        boolean flag = false;
        try {
            IMOperation op = new IMOperation();
            op.addImage(imagePath);
            /** width：裁剪的宽度 * height：裁剪的高度 * x：裁剪的横坐标 * y：裁剪纵坐标 */
            op.crop(width, height, x, y);
            op.addImage(newPath);
            ConvertCmd convert = new ConvertCmd(true);
            convert.run(op);
            flag = true;
        } catch (IOException e) {
            logger.error("读取文件出错", e);
        } catch (InterruptedException e) {
            logger.error("", e);
        } catch (IM4JavaException e) {
            logger.error("", e);
        }
        
        return flag;
    }
    
    /**
     * 根据尺寸缩放图片[等比例缩放:参数height为null,按宽度缩放比例缩放;参数width为null,按高度缩放比例缩放]
     * 
     * @param imagePath
     *            源图片路径
     * @param newPath
     *            处理后图片路径
     * @param width
     *            缩放后的图片宽度
     * @param height
     *            缩放后的图片高度
     * @return 返回true说明缩放成功,否则失败
     */
    public static boolean zoomImage(String imagePath, String newPath, Integer width, Integer height) {
        boolean flag = false;
        try {
            IMOperation op = new IMOperation();
            op.addImage(imagePath);
            if (width == null) {                // 根据高度缩放图片
                op.resize(null, height);
            } else if (height == null) {        // 根据宽度缩放图片
                op.resize(width);
            } else {
                op.resize(width, height);
            }
            op.addImage(newPath);
            ConvertCmd convert = new ConvertCmd(true);
            convert.run(op);
            flag = true;
        } catch (IOException e) {
            logger.error("读取文件出错", e);
        } catch (InterruptedException e) {
            logger.error("", e);
        } catch (IM4JavaException e) {
            logger.error("", e);
        }  
        
        return flag;
    }
    
    /**
     * 图片旋转
     * 
     * @param imagePath
     *            源图片路径
     * @param newPath
     *            处理后图片路径
     * @param degree
     *            旋转角度
     */
    public static boolean rotate(String imagePath, String newPath, double degree) {
        boolean flag = false;
        try {
            // 1.将角度转换到0-360度之间
            degree = degree % 360;
            if (degree <= 0) {
                degree = 360 + degree;
            }
            IMOperation op = new IMOperation();
            op.addImage(imagePath);
            op.rotate(degree);
            op.addImage(newPath);
            ConvertCmd cmd = new ConvertCmd(true);
            cmd.run(op);
            flag = true;
        } catch (Exception e) {
            logger.error("图片旋转处理失败!", e);
        }
        
        return flag;
    }
    
    
    public static boolean imgProcessing(String srcPath, String destPath, int x, int y, int width, int height, double rotate) {
        boolean flag = false;
        try {
            IMOperation op = new IMOperation();
            op.addImage(srcPath);
            /** 旋转 */
            op.rotate(rotate);
            /** width：裁剪的宽度 * height：裁剪的高度 * x：裁剪的横坐标 * y：裁剪纵坐标 */
            op.crop(width, height, x, y);
            op.addImage(destPath);
            ConvertCmd convert = new ConvertCmd(true);
            convert.run(op);
            flag = true;
        } catch (IOException e) {
            logger.error("读取文件出错", e);
        } catch (InterruptedException e) {
            logger.error("", e);
        } catch (IM4JavaException e) {
            logger.error("", e);
        }
        
        return flag;
    }
    
    public static void main(String[] args) {
//        ImageUtils.zoomImage("f://temp//test.jpg", "f://temp//test5.jpg", 200, 200);
//        ImageUtils.rotate("f://temp//test1.jpg", "f://temp//test2.jpg", -90);
//        ImageUtils.cutImage("f://temp//test5.jpg", "f://temp//test5.jpg", 32, 30, 200, 200);
        
        String data = "{'x':100.001, 'y':100.9}";
        
        System.out.println(data);
        
        JSONObject jsonData = JSON.parseObject(data);
        
        
        
        System.out.println(jsonData.getIntValue("x"));
        System.out.println(jsonData.getIntValue("y"));
        
        
    }

}

控制类

package org.hcm.controller;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.hcm.utils.ImageUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;


@Controller
@RequestMapping(value = "/image")
public class ImageController {
    
    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public void upload(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        Map<String, Object> result = new HashMap<String, Object>();
        MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) req;
        MultipartFile file = multipartRequest.getFile("avatar_file");
        String data = req.getParameter("avatar_data");
        String fileName = String.valueOf(System.currentTimeMillis()) + getExtension(file.getOriginalFilename());
        String savePath = req.getServletContext().getRealPath("/upload");
        if (!file.isEmpty()) {
            // 保存原图
            ImageUtils.saveFileFromInputStream(file.getInputStream(), savePath + "\\source\\", fileName);
            // 处理图片
            result = imageProcessing(data, savePath, fileName, req.getContextPath()); 
        } 
        
        resp.getWriter().print(JSON.toJSON(result));
    }

    private Map<String, Object> imageProcessing(String data, String savePath, String fileName, String contextPath) {
        Map<String, Object> map = new HashMap<String, Object>();
        JSONObject object = JSONObject.parseObject(data);
        
        int x = (int) object.getIntValue("x");
        int y = object.getIntValue("y");
        int height = object.getIntValue("height");
        int width = object.getIntValue("width");
        int rotate = object.getIntValue("rotate");
        
        String srcPath = savePath + "\\source\\" + fileName;
        String destPath = savePath + "\\procesed\\" + fileName;
        String serverPath = contextPath + "/upload/procesed/" + fileName;
        
        ImageUtils.imgProcessing(srcPath, destPath, x, y, width, height, rotate);
        
        map.put("state", 200);
        map.put("result", serverPath);
        return map;
        
    }
    
    
    private String getExtension(String fileName) {
        if (StringUtils.INDEX_NOT_FOUND == StringUtils.indexOf(fileName, "."))
            return StringUtils.EMPTY;
        String ext = StringUtils.substring(fileName, StringUtils.lastIndexOf(fileName, "."));
        return StringUtils.trimToEmpty(ext);
    } 
    
}

效果预览

_
_

IM4Java + GraphicsMagick 实现高清图片剪裁处理

（完）

Andriod第三方源码分析

Android进阶之旅-(NDK实战篇之OpenCV）

热门文章