使用JCrop进行图片裁剪，裁剪js说明，裁剪预览，裁剪上传，裁剪设计的图片处理的工具类和代码

<div id="light" class="white_content">

       <div class="vatitlee">

           封面截取

           <div class="guan">

              <a href="javascript:void(0)"

                  onClick="document.getElementById(‘light‘).style.display=‘none‘;document.getElementById(‘fade‘).style.display=‘none‘">X</a>

           </div>

       </div>

       <div class="tailoringc">

           <div class="tailoringl">

              <img id="jcrop_target"

                  src="<c:url value="/resources/cartoon2/images/images/banner7.jpg"/>"

                  width="280" height="553" />

           </div>

           <div class="tailoringr" style=‘overflow: hidden;‘>

              <img id="cutImgId"

                  src="<c:url value="/resources/cartoon2/images/images/banner7.jpg"/>"

                  width="280" height="553" />

           </div>

           <div class="clear"></div>

       </div>

       <div class="tailoringb">

           <a class="button" href="javascript:void(0)" onclick="saveUploadImg()">裁剪</a>

           <a href="javascript:void(0)" class="button"

               onclick="document.getElementById(‘light‘).style.display=‘none‘;document.getElementById(‘fade‘).style.display=‘none‘">取消</a>

       </div>

    </div>

//封面上传,截图

//上传后返回的文件名

    var filename;

    var fileid;

    //裁剪主要用到了jcrop_api

    var jcrop_api,boundx,boundy;

    //原始文件名称

    var originalfilename;

    //实际图片的宽高

    var imgweight,imgheight;

    //dx：实际图片宽/显示宽度

    //dy: 实际图片高/显示高度

    //scale:最终缩放比

//  var dx,dy,scale = 1;

//  var displayW = 175, displayH = 350;

    var imgObj = new Image();

    $(function() {

       init();

    });

    function init() {

       //文件上传的js组件(FileUpload的js组件)

       $(‘#uploadCover‘).fileupload({

            dataType: ‘json‘,

            //autoUpload: true,

            url:‘/contentAffix/upTemp‘,

            done: function (e, data) { 

                if(jcrop_api!=null){

                   jcrop_api.destroy();

                }

                $.each(data.result, function (index, file) {

                    if(index==‘filedesc‘) {

                       //获取文件名称

                       filename=file.filename;

                       //实际的文件高度

                       imgweight = file.imgweight;

                       //实际的文件宽度

                       imgheight = file.imgheight;

//                     //设置缩放比例

//                     dx = imgweight / displayW;

//                     dy = imgheight / displayH;

//                     if(dx > dy && dy > 1) {

//                         scale = dx;

//                        

//                     }

//                     if(dy > dx && dx > 1) {

//                         scale = dy;

//                     }

//                    

//                     displayW = imgweight / scale;

//                     displayH = imgheight / scale;

//                     $("#jcrop_target").css({

//                        width:displayW + ‘px‘,

//                        height:displayH + ‘px‘

//                     });

//                     $(".tailoringc .tailoringl").css({

//                        width:(displayW + 2) + ‘px‘,

//                        height:(displayH + 2) + ‘px‘

//                     });

                       originalfilename = file.originalfilename;

                       fileid=file.id;

                       $(‘#light‘).show();

                     $(‘#fade‘).show();

                       var imgurl = file.filepath+‘/‘+file.filename;

                       $(‘#jcrop_target‘).attr(‘src‘,imgurl);

                       $(‘#cutImgId‘).attr(‘src‘,imgurl);

                       cutPic();

                       //重新加载图像到jcrop，才能小图上正确显示截图位置

                       //jcrop_api.setImage(imgurl);

                    }

                });

            },

        });

       $("#pickCover").click(function () {

           $("#uploadCover").trigger(‘click‘);

       });

       $(‘body‘).data(‘filelist‘, new Array());

    }

//点击裁剪时做的操作

//传递到后台的是最终在实际图片上的位置和宽高

    function saveUploadImg(){

        c = jcrop_api.tellSelect();

        if (parseInt(c.w) > 0) {

            $.ajax({

                  url:‘/cartoon-web/contentAffix/cutimageAndSaveAffix‘,

                  data :{"pointx":Math.round(c.x * imgweight / 280),"pointy":Math.round(c.y * imgheight / 350),"pointw":Math.round(c.w * imgweight / 280),"pointh":Math.round(c.h * imgheight / 350),"filename":filename,"fileid":fileid,"originalfilename":originalfilename},

                  dataType:‘json‘,

                  success: function(data){

                     if(data.result == "success"){

                         $("#fmimg").attr(‘src‘, data.cropImgPath+"?r="+new Date().getTime());

                         $(‘input[type=hidden][name=coverAffixId]‘).val(fileid);

                         $(‘#light‘).hide();

                         $(‘#fade‘).hide();

                         displayW = 280;

                         displayH = 350;

                     }else{

                         alert("请选择图片");

                     }

                  }

            });

        } 

    }

    //保存上传后的文件名称

    function saveReuploadImg(){

       c = jcrop_api.tellSelect();

       var affixId = $(‘#coverAffixId‘).val();

        $.ajax({

           url:‘/cartoon-web/contentAffix/cutimageAndUpdateAffix‘,

           data :{

              "pointx":Math.round(c.x),

              "pointy":Math.round(c.y),

              "pointw":Math.round(c.w),

              "pointh":Math.round(c.h),

              "filename":filename,

              "fileid":fileid,

              "originalfilename":originalfilename,

              "affixId":affixId

           },

           dataType:‘json‘,

           success: function(data){

              if(data.result == "success") {

                  $("#fmimg").attr(‘src‘, data.cropImgPath+"?r="+new Date().getTime());

                  $(‘input[type=hidden][name=coverAffixId]‘).val(fileid);

                  $(‘#light‘).hide();

                  $(‘#fade‘).hide();

              }else{

                  alert("请选择图片");

              }

           }

       });

    }

    //显示预览

    function showPreview(c){

       if (parseInt(c.w) > 0) {

           var rx = 280 / c.w;

           var ry = 175 / c.h;

           var bounds = jcrop_api.getBounds();

           boundx = bounds[0];

           boundy = bounds[1];

           $(‘#cutImgId‘).css({

              width:Math.round(rx * boundx) + ‘px‘,

              height:Math.round(ry * boundy) + ‘px‘,

              marginLeft:‘-‘ + Math.round(rx * c.x) + ‘px‘,

              marginTop:‘-‘ + Math.round(ry * c.y) + ‘px‘,

           });

       }

    }

    function cutPic(){

       imgObj = new Image();

       imgObj.src = jcrop_target.src;

       jcrop_api = $.Jcrop(‘#jcrop_target‘,{

            onChange: showPreview,//选框改变时的事件

            onSelect: showPreview,//选框选定时的事件

            handleSize:1,//缩放按钮大小

            drawBorders:false,//绘制边框

            aspectRatio: 280/175,//选框宽高比。说明：width/height

            allowResize:true,

            allowSelect:false, //允许新选框

         //   bgColor:"#ccc",  //背景色

//          minSize: [50,50],

//          allowMove: true,

//          allowResize:false,

//          allowSelect:true, //允许新选框

//          cornerHandles:false,  //允许边角缩放

//          sideHandles:false,  //允许四边缩放

//          handleSize:9,

//          drawBorders:true, //绘制边框

            dragEdges:true,  //允许拖动边框

//         //bgOpacity:0.9, //透明度

//           onChange:showPreview, //当选择区域变化的时候，执行对应的回调函数

//          onSelect:showPreview, //当选中区域的时候，执行对应的回调函数

//          aspectRatio:1, //正方形

            //setSelect:[300,300,300,300,0,0]

        });

       //设置选择框默认位置

       jcrop_api.animateTo([0,0,280,175]);

    };

/**

     * 上传图片的临时目录，截图前的预览,不保存

     *

     * @param param

     * @param imageFile

     * @return

     */

    @ResponseBody

    @RequestMapping(value = "/upTemp", method = RequestMethod.POST, produces = "application/json")

    public Map<String, Object> upTemp(@RequestParam Map<String, String> param,

           @RequestParam("file") MultipartFile imageFile) {

       Map<String, Object> result = new HashMap<String, Object>();

       if (!imageFile.isEmpty()) {

           Map<String, String> filedesc = new HashMap<String, String>();

           String uuid = FileUtils.genFileName();// uuid形成的文件名称

           String filename = uuid;

           try {

              // 新文件名

              String uuIDFileName = uuid;

              // 存放路径

              String path = CommonVar.getLocalTempPath()

                     + FileUtils.genFilePathCover(FilePathType.COVER);

              path = path.replace("\\", "/").replace("//", "/");

              // 原文件名

              String srcName = imageFile.getOriginalFilename();

              // 新文件名

              String newFileName = uuIDFileName

                     + srcName.substring(srcName.indexOf("."));

              // 保存文件路径(临时文件夹下)

              String saveURL = path + "/" + newFileName;

              LOGGER.debug(saveURL);

              // 写文件

              InputStream fi = imageFile.getInputStream();

              FileUtils.writeFile(fi, saveURL);

              // 等比缩图

              zoomOutImg(saveURL);

              int[] imgWH = getImageWH(saveURL);

              String webpath = CommonVar.getWebTempPath()

                     + FileUtils.genFilePathCover(FilePathType.COVER);

              webpath = webpath.replace("\\", "/");

              filedesc.put("id", uuid);

              // filedesc.put("filetype", "3");

              filedesc.put("contenttype", imageFile.getContentType());

              filedesc.put("name", filename);// uuid

              filedesc.put("filename", newFileName);// 有后缀

              filedesc.put("originalfilename",

                     imageFile.getOriginalFilename());

              filedesc.put("filepath", webpath);

              filedesc.put("imgweight", imgWH[0] + "");

              filedesc.put("imgheight", imgWH[1] + "");

              result.put("filedesc", filedesc);

           } catch (Exception e) {

              e.printStackTrace();

           }

       }

       return result;

    }

private int[] getImageWH(String saveURL) {

       int[] imgWH = { 0, 0 };

       try {

           BufferedImage bimg = operatorImage.getBufferedImage(saveURL);

           imgWH[0] = bimg.getWidth();

           imgWH[1] = bimg.getHeight();

       } catch (IOException e) {

           e.printStackTrace();

       }

       return imgWH;

    }

private void zoomOutImg(String saveURL) throws IOException {

       int ratio = operatorImage.getImgRatio(saveURL, CommonVar.LOGO_SCALE);

       operatorImage.reduceImageEqualProportion(saveURL, saveURL, ratio);

    }

package com.kuman.cartoon.utils;

import java.awt.AlphaComposite;

import java.awt.Color;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.Graphics2D;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.color.ColorSpace;

import java.awt.image.BufferedImage;

import java.awt.image.ColorConvertOp;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.util.Iterator;

import java.util.List;

import javax.imageio.ImageIO;

import javax.imageio.ImageReadParam;

import javax.imageio.ImageReader;

import javax.imageio.stream.ImageInputStream;

import org.springframework.stereotype.Service;

import com.kuman.cartoon.common.CommonVar;

//import com.sun.image.codec.jpeg.JPEGCodec;

//import com.sun.image.codec.jpeg.JPEGImageEncoder;

@Service

public class OperateImage {

         public OperateImage() {

                   super();

         }

         /**

          * 对图片裁剪，并把裁剪新图片保存

          *

          * @param srcPath

          *            读取源图片路径

          * @param toPath

          *            写入图片路径

          * @param x

          *            剪切起始点x坐标

          * @param y

          *            剪切起始点y坐标

          * @param width

          *            剪切宽度

          * @param height

          *            剪切高度

          * @param readImageFormat

          *            读取图片格式

          * @param writeImageFormat

          *            写入图片格式

          * @throws IOException

          */

         public void cropImage(String srcPath, String toPath, int x, int y,

                            int width, int height, String readImageFormat,

                            String writeImageFormat) throws IOException {

                   FileInputStream fis = null;

                   ImageInputStream iis = null;

                   try {

                            // 读取图片文件

                            fis = new FileInputStream(srcPath);

                            Iterator it = ImageIO.getImageReadersByFormatName(readImageFormat);

                            ImageReader reader = (ImageReader) it.next();

                            // 获取图片流

                            iis = ImageIO.createImageInputStream(fis);

                            reader.setInput(iis, true);

                            ImageReadParam param = reader.getDefaultReadParam();

                            // 定义一个矩形

                            Rectangle rect = new Rectangle(x, y, width, height);

                            // 提供一个 BufferedImage，将其用作解码像素数据的目标。

                            param.setSourceRegion(rect);

                            BufferedImage bi = reader.read(0, param);

                            // 保存新图片

                            ImageIO.write(bi, writeImageFormat, new File(toPath));

                   } finally {

                            if (fis != null)

                                     fis.close();

                            if (iis != null)

                                     iis.close();

                   }

         }

         /**

          * 按倍率缩小图片

          *

          * @param srcImagePath

          *            读取图片路径

          * @param toImagePath

          *            写入图片路径

          * @param widthRatio

          *            宽度缩小比例

          * @param heightRatio

          *            高度缩小比例

          * @throws IOException

          */

         public void reduceImageByRatio(String srcImagePath, String toImagePath,

                            int widthRatio, int heightRatio) throws IOException {

                   // FileOutputStream out = null;

                   try {

                            // 读入文件

                            File file = new File(srcImagePath);

                            // 构造Image对象

                            BufferedImage src = javax.imageio.ImageIO.read(file);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            // 缩小边长

                            BufferedImage tag = new BufferedImage(width / widthRatio, height

                                               / heightRatio, BufferedImage.TYPE_INT_RGB);

                            // 绘制 缩小 后的图片

                            tag.getGraphics().drawImage(src, 0, 0, width / widthRatio,

                                               height / heightRatio, null);

                            // out = new FileOutputStream(toImagePath);

                            // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

                            // encoder.encode(tag);

                            String formatName = toImagePath.substring(toImagePath

                                               .lastIndexOf(".") + 1);

                            ImageIO.write(tag, /* "GIF" */formatName /* format desired */,

                                               new File(toImagePath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (out != null) {

                            // out.close();

                            // }

                   }

         }

         /**

          * @param srcImgPath

          * @return

          * @throws IOException

          */

         public BufferedImage getBufferedImage(String srcImgPath) throws IOException {

                   File file = new File(srcImgPath);

                   // 构造Image对象

                   return javax.imageio.ImageIO.read(file);

         }

         /**

          * 获得图片获得缩小比例，根据图片长宽，

          *

          * @param srcImgPath

          *            原始图片路径

          * @param scale

          *            需要的图片大小

          * @return (int)(min(width,height)/scale)

          */

         public int getImgRatio(String srcImgPath, float scale) {

                   int defaultScale = 1;

                   try {

                            BufferedImage src = getBufferedImage(srcImgPath);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            int minV = width > height ? height : width;

                            // 向下取整

                            double v = Math.floor(minV / scale);

                            defaultScale = (int) v;

                   } catch (IOException e) {

                            e.printStackTrace();

                            return defaultScale;

                   }

                   defaultScale = (defaultScale == 0) ? 1 : defaultScale;

                   return defaultScale;

         }

         /**

          * 获得图片获得缩小比例，根据图片宽度与高度，宽度大于高度以宽为标准，宽度小于高度以高度为标准缩小或放大

          *

          * @param srcImgPath

          *            原始图片路径

          * @param scale

          *            需要的图片大小

          * @return (int)(width/scale)

          */

         public int getImgRatioByWidthAndHeight(String srcImgPath) {

                   int defaultScale = 1;

                   try {

                            BufferedImage src = getBufferedImage(srcImgPath);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            float scale = width > height ? CommonVar.COVER_WIDTH_SCALE

                                               : CommonVar.COVER_HEIGHT_SCALE;

                            int minV = width > height ? width : height;

                            // 向下取整

                            double v = Math.floor(minV / scale);

                            defaultScale = (int) v;

                   } catch (IOException e) {

                            e.printStackTrace();

                            return defaultScale;

                   }

                   defaultScale = (defaultScale == 0) ? 1 : defaultScale;

                   return defaultScale;

         }

         /**

          * 长高等比例缩小图片

          *

          * @param srcImagePath

          *            读取图片路径

          * @param toImagePath

          *            写入图片路径

          * @param ratio

          *            缩小比例

          * @throws IOException

          */

         public void reduceImageEqualProportion(String srcImagePath,

                            String toImagePath, int ratio) throws IOException {

                   // FileOutputStream out = null;

                   try {

                            // 读入文件

                            File file = new File(srcImagePath);

                            // 构造Image对象

                            BufferedImage src = javax.imageio.ImageIO.read(file);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            // 缩小边长

                            BufferedImage tag = new BufferedImage(width / ratio,

                                               height / ratio, BufferedImage.TYPE_INT_RGB);

                            // 绘制 缩小 后的图片

                            tag.getGraphics().drawImage(src, 0, 0, width / ratio,

                                               height / ratio, null);

                            // out = new FileOutputStream(toImagePath);

                            // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

                            // encoder.encode(tag);

                            String formatName = toImagePath.substring(toImagePath

                                               .lastIndexOf(".") + 1);

                            ImageIO.write(tag, /* "GIF" */formatName /* format desired */,

                                               new File(toImagePath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (out != null) {

                            // out.close();

                            // }

                   }

         }

         /**

          * 按倍率放大图片

          *

          * @param srcImagePath

          *            读取图形路径

          * @param toImagePath

          *            写入入行路径

          * @param widthRatio

          *            宽度放大比例

          * @param heightRatio

          *            高度放大比例

          * @throws IOException

          */

         public void enlargementImageByRatio(String srcImagePath,

                            String toImagePath, int widthRatio, int heightRatio)

                            throws IOException {

                   // FileOutputStream out = null;

                   try {

                            // 读入文件

                            File file = new File(srcImagePath);

                            // 构造Image对象

                            BufferedImage src = javax.imageio.ImageIO.read(file);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            // 放大边长

                            BufferedImage tag = new BufferedImage(width * widthRatio, height

                                               * heightRatio, BufferedImage.TYPE_INT_RGB);

                            // 绘制放大后的图片

                            tag.getGraphics().drawImage(src, 0, 0, width * widthRatio,

                                               height * heightRatio, null);

                            // out = new FileOutputStream(toImagePath);

                            // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

                            // encoder.encode(tag);

                            String formatName = toImagePath.substring(toImagePath

                                               .lastIndexOf(".") + 1);

                            ImageIO.write(tag, /* "GIF" */formatName /* format desired */,

                                               new File(toImagePath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (out != null) {

                            // out.close();

                            // }

                   }

         }

         /**

          * 长高等比例放大图片

          *

          * @param srcImagePath

          *            读取图形路径

          * @param toImagePath

          *            写入入行路径

          * @param ratio

          *            放大比例

          * @throws IOException

          */

         public void enlargementImageEqualProportion(String srcImagePath,

                            String toImagePath, int ratio) throws IOException {

                   // FileOutputStream out = null;

                   try {

                            // 读入文件

                            File file = new File(srcImagePath);

                            // 构造Image对象

                            BufferedImage src = javax.imageio.ImageIO.read(file);

                            int width = src.getWidth();

                            int height = src.getHeight();

                            // 放大边长

                            BufferedImage tag = new BufferedImage(width * ratio,

                                               height * ratio, BufferedImage.TYPE_INT_RGB);

                            // 绘制放大后的图片

                            tag.getGraphics().drawImage(src, 0, 0, width * ratio,

                                               height * ratio, null);

                            // out = new FileOutputStream(toImagePath);

                            // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

                            // encoder.encode(tag);

                            String formatName = toImagePath.substring(toImagePath

                                               .lastIndexOf(".") + 1);

                            ImageIO.write(tag, /* "GIF" */formatName /* format desired */,

                                               new File(toImagePath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (out != null) {

                            // out.close();

                            // }

                   }

         }

         /**

          * 重置图形的边长大小

          *

          * @param srcImagePath

          * @param toImagePath

          * @param width

          * @param height

          * @throws IOException

          */

         public void resizeImage(String srcImagePath, String toImagePath, int width,

                            int height) throws IOException {

                   // FileOutputStream out = null;

                   try {

                            // 读入文件

                            File file = new File(srcImagePath);

                            // 构造Image对象

                            BufferedImage src = javax.imageio.ImageIO.read(file);

                            // 放大边长

                            BufferedImage tag = new BufferedImage(width, height,

                                               BufferedImage.TYPE_INT_RGB);

                            // 绘制放大后的图片

                            tag.getGraphics().drawImage(src, 0, 0, width, height, null);

                            // out = new FileOutputStream(toImagePath);

                            // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);

                            // encoder.encode(tag);

                            String formatName = toImagePath.substring(toImagePath

                                               .lastIndexOf(".") + 1);

                            ImageIO.write(tag, /* "GIF" */formatName /* format desired */,

                                               new File(toImagePath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (out != null) {

                            // out.close();

                            // }

                   }

         }

         /**

          * 横向拼接图片（两张）

          *

          * @param firstSrcImagePath

          *            第一张图片的路径

          * @param secondSrcImagePath

          *            第二张图片的路径

          * @param imageFormat

          *            拼接生成图片的格式

          * @param toPath

          *            拼接生成图片的路径

          */

         public void joinImagesHorizontal(String firstSrcImagePath,

                            String secondSrcImagePath, String imageFormat, String toPath) {

                   try {

                            // 读取第一张图片

                            File fileOne = new File(firstSrcImagePath);

                            BufferedImage imageOne = ImageIO.read(fileOne);

                            int width = imageOne.getWidth();// 图片宽度

                            int height = imageOne.getHeight();// 图片高度

                            // 从图片中读取RGB

                            int[] imageArrayOne = new int[width * height];

                            imageArrayOne = imageOne.getRGB(0, 0, width, height, imageArrayOne,

                                               0, width);

                            // 对第二张图片做相同的处理

                            File fileTwo = new File(secondSrcImagePath);

                            BufferedImage imageTwo = ImageIO.read(fileTwo);

                            int width2 = imageTwo.getWidth();

                            int height2 = imageTwo.getHeight();

                            int[] ImageArrayTwo = new int[width2 * height2];

                            ImageArrayTwo = imageTwo.getRGB(0, 0, width, height, ImageArrayTwo,

                                               0, width);

                            // ImageArrayTwo =

                            // imageTwo.getRGB(0,0,width2,height2,ImageArrayTwo,0,width2);

                            // 生成新图片

                            // int height3 = (height>height2 || height==height2)?height:height2;

                            BufferedImage imageNew = new BufferedImage(width * 2, height,

                                               BufferedImage.TYPE_INT_RGB);

                            // BufferedImage imageNew = new

                            // BufferedImage(width+width2,height3,BufferedImage.TYPE_INT_RGB);

                            imageNew.setRGB(0, 0, width, height, imageArrayOne, 0, width);// 设置左半部分的RGB

                            imageNew.setRGB(width, 0, width, height, ImageArrayTwo, 0, width);// 设置右半部分的RGB

                            // imageNew.setRGB(width,0,width2,height2,ImageArrayTwo,0,width2);//设置右半部分的RGB

                            File outFile = new File(toPath);

                            ImageIO.write(imageNew, imageFormat, outFile);// 写图片

                   } catch (Exception e) {

                            e.printStackTrace();

                   }

         }

         /**

          * 横向拼接一组（多张）图像

          *

          * @param pics

          *            将要拼接的图像

          * @param type

          *            图像写入格式

          * @param dst_pic

          *            图像写入路径

          * @return

          */

         public boolean joinImageListHorizontal(String[] pics, String type,

                            String dst_pic) {

                   try {

                            int len = pics.length;

                            if (len < 1) {

                                     // System.out.println("pics len < 1");

                                     return false;

                            }

                            File[] src = new File[len];

                            BufferedImage[] images = new BufferedImage[len];

                            int[][] imageArrays = new int[len][];

                            for (int i = 0; i < len; i++) {

                                     src[i] = new File(pics[i]);

                                     images[i] = ImageIO.read(src[i]);

                                     int width = images[i].getWidth();

                                     int height = images[i].getHeight();

                                     imageArrays[i] = new int[width * height];// 从图片中读取RGB

                                     imageArrays[i] = images[i].getRGB(0, 0, width, height,

                                                        imageArrays[i], 0, width);

                            }

                            int dst_width = 0;

                            int dst_height = images[0].getHeight();

                            for (int i = 0; i < images.length; i++) {

                                     dst_height = dst_height > images[i].getHeight() ? dst_height

                                                        : images[i].getHeight();

                                      dst_width += images[i].getWidth();

                            }

                            // System.out.println(dst_width);

                            // System.out.println(dst_height);

                            if (dst_height < 1) {

                                     // System.out.println("dst_height < 1");

                                     return false;

                            }

                            /*

                             * 生成新图片

                             */

                            BufferedImage ImageNew = new BufferedImage(dst_width, dst_height,

                                               BufferedImage.TYPE_INT_RGB);

                            int width_i = 0;

                            for (int i = 0; i < images.length; i++) {

                                     ImageNew.setRGB(width_i, 0, images[i].getWidth(), dst_height,

                                                        imageArrays[i], 0, images[i].getWidth());

                                     width_i += images[i].getWidth();

                            }

                            File outFile = new File(dst_pic);

                            ImageIO.write(ImageNew, type, outFile);// 写图片

                   } catch (Exception e) {

                            e.printStackTrace();

                            return false;

                   }

                   return true;

         }

         /**

          * 纵向拼接图片（两张）

          *

          * @param firstSrcImagePath

          *            读取的第一张图片

          * @param secondSrcImagePath

          *            读取的第二张图片

          * @param imageFormat

          *            图片写入格式

          * @param toPath

          *            图片写入路径

          */

         public void joinImagesVertical(String firstSrcImagePath,

                            String secondSrcImagePath, String imageFormat, String toPath) {

                   try {

                            // 读取第一张图片

                            File fileOne = new File(firstSrcImagePath);

                            BufferedImage imageOne = ImageIO.read(fileOne);

                            int width = imageOne.getWidth();// 图片宽度

                            int height = imageOne.getHeight();// 图片高度

                            // 从图片中读取RGB

                            int[] imageArrayOne = new int[width * height];

                            imageArrayOne = imageOne.getRGB(0, 0, width, height, imageArrayOne,

                                               0, width);

                            // 对第二张图片做相同的处理

                            File fileTwo = new File(secondSrcImagePath);

                            BufferedImage imageTwo = ImageIO.read(fileTwo);

                            int width2 = imageTwo.getWidth();

                            int height2 = imageTwo.getHeight();

                            int[] ImageArrayTwo = new int[width2 * height2];

                            ImageArrayTwo = imageTwo.getRGB(0, 0, width, height, ImageArrayTwo,

                                               0, width);

                            // ImageArrayTwo =

                            // imageTwo.getRGB(0,0,width2,height2,ImageArrayTwo,0,width2);

                            // 生成新图片

                            // int width3 = (width>width2 || width==width2)?width:width2;

                            BufferedImage imageNew = new BufferedImage(width, height * 2,

                                               BufferedImage.TYPE_INT_RGB);

                            // BufferedImage imageNew = new

                            // BufferedImage(width3,height+height2,BufferedImage.TYPE_INT_RGB);

                            imageNew.setRGB(0, 0, width, height, imageArrayOne, 0, width);// 设置上半部分的RGB

                            imageNew.setRGB(0, height, width, height, ImageArrayTwo, 0, width);// 设置下半部分的RGB

                            // imageNew.setRGB(0,height,width2,height2,ImageArrayTwo,0,width2);//设置下半部分的RGB

                            File outFile = new File(toPath);

                            ImageIO.write(imageNew, imageFormat, outFile);// 写图片

                   } catch (Exception e) {

                            e.printStackTrace();

                   }

         }

         /**

          * 纵向拼接一组（多张）图像

          *

          * @param pics

          *            将要拼接的图像数组

          * @param type

          *            写入图像类型

          * @param dst_pic

          *            写入图像路径

          * @return

          */

         public boolean joinImageListVertical(String[] pics, String type,

                            String dst_pic) {

                   try {

                            int len = pics.length;

                            if (len < 1) {

                                     System.out.println("pics len < 1");

                                     return false;

                            }

                            File[] src = new File[len];

                            BufferedImage[] images = new BufferedImage[len];

                            int[][] imageArrays = new int[len][];

                            for (int i = 0; i < len; i++) {

                                     // System.out.println(i);

                                     src[i] = new File(pics[i]);

                                     images[i] = ImageIO.read(src[i]);

                                     int width = images[i].getWidth();

                                     int height = images[i].getHeight();

                                     imageArrays[i] = new int[width * height];// 从图片中读取RGB

                                     imageArrays[i] = images[i].getRGB(0, 0, width, height,

                                                        imageArrays[i], 0, width);

                            }

                            int dst_height = 0;

                            int dst_width = images[0].getWidth();

                            for (int i = 0; i < images.length; i++) {

                                     dst_width = dst_width > images[i].getWidth() ? dst_width

                                                        : images[i].getWidth();

                                     dst_height += images[i].getHeight();

                            }

                            // System.out.println(dst_width);

                            // System.out.println(dst_height);

                            if (dst_height < 1) {

                                     System.out.println("dst_height < 1");

                                     return false;

                            }

                            /*

                             * 生成新图片

                             */

                            BufferedImage ImageNew = new BufferedImage(dst_width, dst_height,

                                               BufferedImage.TYPE_INT_RGB);

                            int height_i = 0;

                            for (int i = 0; i < images.length; i++) {

                                     ImageNew.setRGB(0, height_i, dst_width, images[i].getHeight(),

                                                        imageArrays[i], 0, dst_width);

                                     height_i += images[i].getHeight();

                            }

                            File outFile = new File(dst_pic);

                            ImageIO.write(ImageNew, type, outFile);// 写图片

                   } catch (Exception e) {

                            e.printStackTrace();

                            return false;

                   }

                   return true;

         }

         /**

          * 合并图片(按指定初始x、y坐标将附加图片贴到底图之上)

          *

          * @param negativeImagePath

          *            背景图片路径

          * @param additionImagePath

          *            附加图片路径

          * @param x

          *            附加图片的起始点x坐标

          * @param y

          *            附加图片的起始点y坐标

          * @param toPath

          *            图片写入路径

          * @throws IOException

          */

         public void mergeBothImage(String negativeImagePath,

                            String additionImagePath, int x, int y, String toPath)

                            throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   // OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            is2 = new FileInputStream(additionImagePath);

                            BufferedImage image = ImageIO.read(is);

                            BufferedImage image2 = ImageIO.read(is2);

                            Graphics g = image.getGraphics();

                            g.drawImage(image2, x, y, null);

                            // os = new FileOutputStream(toPath);

                            // JPEGImageEncoder enc = JPEGCodec.createJPEGEncoder(os);

                            // enc.encode(image);

                            String formatName = toPath.substring(toPath.lastIndexOf(".") + 1);

                            ImageIO.write(image, /* "GIF" */formatName /* format desired */,

                                               new File(toPath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (os != null) {

                            // os.close();

                            // }

                            if (is2 != null) {

                                     is2.close();

                            }

                            if (is != null) {

                                     is.close();

                            }

                   }

         }

         /**

          * 将一组图片一次性附加合并到底图上

          *

          * @param negativeImagePath

          *            源图像（底图）路径

          * @param additionImageList

          *            附加图像信息列表

          * @param imageFormat

          *            图像写入格式

          * @param toPath

          *            图像写入路径

          * @throws IOException

          */

         public void mergeImageList(String negativeImagePath,

                            List additionImageList, String imageFormat, String toPath)

                            throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            BufferedImage image = ImageIO.read(is);

                            // Graphics g=image.getGraphics();

                            Graphics2D g = image.createGraphics();

                            ;

                            BufferedImage image2 = null;

                            if (additionImageList != null) {

                                     for (int i = 0; i < additionImageList.size(); i++) {

                                               // 解析附加图片信息：x坐标、 y坐标、 additionImagePath附加图片路径

                                               // 图片信息存储在一个数组中

                                               String[] additionImageInfo = (String[]) additionImageList

                                                                 .get(i);

                                               int x = Integer.parseInt(additionImageInfo[0]);

                                               int y = Integer.parseInt(additionImageInfo[1]);

                                               String additionImagePath = additionImageInfo[2];

                                               // 读取文件输入流，并合并图片

                                               is2 = new FileInputStream(additionImagePath);

                                               // System.out.println(x+"  :  "+y+"  :  "+additionImagePath);

                                               image2 = ImageIO.read(is2);

                                               g.drawImage(image2, x, y, null);

                                     }

                            }

                            os = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, os);// 写图片

                            // JPEGImageEncoder enc=JPEGCodec.createJPEGEncoder(os);

                            // enc.encode(image);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            if (os != null) {

                                     os.close();

                            }

                            if (is2 != null) {

                                     is2.close();

                            }

                            if (is != null) {

                                     is.close();

                            }

                   }

         }

         /**

          * 将附加图片合并到底图的左上角

          *

          * @param negativeImagePath

          *            底图路径

          * @param additionImagePath

          *            附加图片路径

          * @param toPath

          *            合成图片写入路径

          * @throws IOException

          */

         public void mergeBothImageTopleftcorner(String negativeImagePath,

                            String additionImagePath, String toPath) throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   // OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            is2 = new FileInputStream(additionImagePath);

                            BufferedImage image = ImageIO.read(is);

                            BufferedImage image2 = ImageIO.read(is2);

                            Graphics g = image.getGraphics();

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

                            // os = new FileOutputStream(toPath);

                            // JPEGImageEncoder enc = JPEGCodec.createJPEGEncoder(os);

                            // enc.encode(image);

                            String formatName = toPath.substring(toPath.lastIndexOf(".") + 1);

                            ImageIO.write(image, /* "GIF" */formatName /* format desired */,

                                               new File(toPath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (os != null) {

                            // os.close();

                            // }

                            if (is2 != null) {

                                     is2.close();

                            }

                            if (is != null) {

                                     is.close();

                            }

                   }

         }

         /**

          * 将附加图片合并到底图的右上角

          *

          * @param negativeImagePath

          *            底图路径

          * @param additionImagePath

          *            附加图片路径

          * @param toPath

          *            合成图片写入路径

          * @throws IOException

          */

         public void mergeBothImageToprightcorner(String negativeImagePath,

                            String additionImagePath, String toPath) throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   // OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            is2 = new FileInputStream(additionImagePath);

                            BufferedImage image = ImageIO.read(is);

                            BufferedImage image2 = ImageIO.read(is2);

                            Graphics g = image.getGraphics();

                            g.drawImage(image2, image.getWidth() - image2.getWidth(), 0, null);

                            // os = new FileOutputStream(toPath);

                            // JPEGImageEncoder enc = JPEGCodec.createJPEGEncoder(os);

                            // enc.encode(image);

                            //

                            String formatName = toPath.substring(toPath.lastIndexOf(".") + 1);

                            ImageIO.write(image, /* "GIF" */formatName /* format desired */,

                                               new File(toPath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (os != null) {

                            // os.close();

                            // }

                            if (is2 != null) {

                                     is2.close();

                            }

                            if (is != null) {

                                     is.close();

                            }

                   }

         }

         /**

          * 将附加图片合并到底图的左下角

          *

          * @param negativeImagePath

          *            底图路径

          * @param additionImagePath

          *            附加图片路径

          * @param toPath

          *            合成图片写入路径

          * @throws IOException

          */

         public void mergeBothImageLeftbottom(String negativeImagePath,

                            String additionImagePath, String toPath) throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   // OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            is2 = new FileInputStream(additionImagePath);

                            BufferedImage image = ImageIO.read(is);

                            BufferedImage image2 = ImageIO.read(is2);

                            Graphics g = image.getGraphics();

                            g.drawImage(image2, 0, image.getHeight() - image2.getHeight(), null);

                            // os = new FileOutputStream(toPath);

                            // JPEGImageEncoder enc = JPEGCodec.createJPEGEncoder(os);

                            // enc.encode(image);

                            String formatName = toPath.substring(toPath.lastIndexOf(".") + 1);

                            ImageIO.write(image, /* "GIF" */formatName /* format desired */,

                                               new File(toPath) /* target */);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            // if (os != null) {

                            // os.close();

                            // }

                            if (is2 != null) {

                                     is2.close();

                            }

                            if (is != null) {

                                     is.close();

                            }

                   }

         }

         /**

          * 将附加图片合并到底图的左下角

          *

          * @param negativeImagePath

          *            底图路径

          * @param additionImagePath

          *            附加图片路径

          * @param toPath

          *            合成图片写入路径

          * @throws IOException

          */

         public void mergeBothImageRightbottom(String negativeImagePath,

                            String additionImagePath, String toPath) throws IOException {

                   InputStream is = null;

                   InputStream is2 = null;

                   // OutputStream os = null;

                   try {

                            is = new FileInputStream(negativeImagePath);

                            is2 = new FileInputStream(additionImagePath);