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

JCrop   2015-09-11 22:56:38 发布
您的评价:
     
0.0
收藏     0收藏
文件夹
标签
(多个标签用逗号分隔)

1.要想制作图片裁剪功能,可以使用网上的裁剪工具JCrop,网址是:https://github.com/tapmodo/Jcrop/

案例效果如下:

2.引入JCropjs代码,具体要引入那些js可以参考JCrop案例:

3.编写的html代码如下:

<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>

4编写JS代码(注意这里的280175表示的是我要一张长为280px像素高175px像素的图片):

//封面上传,截图

//上传后返回的文件名

    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组件(FileUploadjs组件)

       $('#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]);

    };

5 编写后端代码:

/**

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

     *

     * @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;

    }

6 获取图片的宽高的代码:

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;

    }

7 压缩与等比缩放的代码:

private void zoomOutImg(String saveURL) throws IOException {

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

       operatorImage.reduceImageEqualProportion(saveURL, saveURL, ratio);

    }

8 操作图片资源的工具类:

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;

         }

 

         /**

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

          *

          * @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);

                            BufferedImage image = ImageIO.read(is);

                            BufferedImage image2 = ImageIO.read(is2);

                            Graphics g = image.getGraphics();

                            g.drawImage(image2, image.getWidth() - image2.getWidth(),

                                               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 mergeBothImageCenter(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() / 2 - image2.getWidth() / 2,

                                               image.getHeight() / 2 - image2.getHeight() / 2, 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 mergeBothImageTopcenter(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() / 2 - image2.getWidth() / 2,

                                               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 mergeBothImageBottomcenter(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() / 2 - image2.getWidth() / 2,

                                               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 mergeBothImageLeftcenter(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() / 2 - image2.getHeight()

                                               / 2, 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 mergeBothImageRightcenter(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(),

                                               image.getHeight() / 2 - image2.getHeight() / 2, 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 srcImage

          *            读取图片路径

          * @param toPath

          *            写入灰化后的图片路径

          * @param imageFormat

          *            图片写入格式

          */

         public void grayImage(String srcImage, String toPath, String imageFormat) {

                   try {

                            BufferedImage src = ImageIO.read(new File(srcImage));

                            ColorSpace cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);

                            ColorConvertOp op = new ColorConvertOp(cs, null);

                            src = op.filter(src, null);

                            ImageIO.write(src, imageFormat, new File(toPath));

                   } catch (Exception e) {

                            e.printStackTrace();

                   }

         }

 

         /**

          * 在源图片上设置水印文字

          *

          * @param srcImagePath

          *            源图片路径

          * @param alpha

          *            透明度(0<alpha<1

          * @param font

          *            字体(例如:宋体)

          * @param fontStyle

          *            字体格式(例如:普通样式--Font.PLAIN、粗体--Font.BOLD )

          * @param fontSize

          *            字体大小

          * @param color

          *            字体颜色(例如:黑色--Color.BLACK)

          * @param inputWords

          *            输入显示在图片上的文字

          * @param x

          *            文字显示起始的x坐标

          * @param y

          *            文字显示起始的y坐标

          * @param imageFormat

          *            写入图片格式(png/jpg等)

          * @param toPath

          *            写入图片路径

          * @throws IOException

          */

         public void alphaWords2Image(String srcImagePath, float alpha, String font,

                            int fontStyle, int fontSize, Color color, String inputWords, int x,

                            int y, String imageFormat, String toPath) throws IOException {

                   FileOutputStream fos = null;

                   try {

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 创建java2D对象

                            Graphics2D g2d = image.createGraphics();

                            // 用源图像填充背景

                            g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(),

                                               null, null);

                            // 设置透明度

                            AlphaComposite ac = AlphaComposite.getInstance(

                                               AlphaComposite.SRC_OVER, alpha);

                            g2d.setComposite(ac);

                            // 设置文字字体名称、样式、大小

                            g2d.setFont(new Font(font, fontStyle, fontSize));

                            g2d.setColor(color);// 设置字体颜色

                            g2d.drawString(inputWords, x, y); // 输入水印文字及其起始xy坐标

                            g2d.dispose();

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 在源图像上设置图片水印 ---- alpha==1时文字不透明(和在图片上直接输入文字效果一样)

          *

          * @param srcImagePath

          *            源图片路径

          * @param appendImagePath

          *            水印图片路径

          * @param alpha

          *            透明度

          * @param x

          *            水印图片的起始x坐标

          * @param y

          *            水印图片的起始y坐标

          * @param width

          *            水印图片的宽度

          * @param height

          *            水印图片的高度

          * @param imageFormat

          *            图像写入图片格式

          * @param toPath

          *            图像写入路径

          * @throws IOException

          */

         public void alphaImage2Image(String srcImagePath, String appendImagePath,

                            float alpha, int x, int y, int width, int height,

                            String imageFormat, String toPath) throws IOException {

                   FileOutputStream fos = null;

                   try {

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 创建java2D对象

                            Graphics2D g2d = image.createGraphics();

                            // 用源图像填充背景

                            g2d.drawImage(image, 0, 0, image.getWidth(), image.getHeight(),

                                               null, null);

                            // 设置透明度

                            AlphaComposite ac = AlphaComposite.getInstance(

                                               AlphaComposite.SRC_OVER, alpha);

                            g2d.setComposite(ac);

                            // 设置水印图片的起始x/y坐标、宽度、高度

                            BufferedImage appendImage = ImageIO.read(new File(appendImagePath));

                            g2d.drawImage(appendImage, x, y, width, height, null, null);

                            g2d.dispose();

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 画单点 ---- 实际上是画一个填充颜色的圆 ---- 以指定点坐标为中心画一个小半径的圆形,并填充其颜色来充当点

          *

          * @param srcImagePath

          *            源图片颜色

          * @param x

          *            点的x坐标

          * @param y

          *            点的y坐标

          * @param width

          *            填充的宽度

          * @param height

          *            填充的高度

          * @param ovalColor

          *            填充颜色

          * @param imageFormat

          *            写入图片格式

          * @param toPath

          *            写入路径

          * @throws IOException

          */

         public void drawPoint(String srcImagePath, int x, int y, int width,

                            int height, Color ovalColor, String imageFormat, String toPath)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取源图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制连接线

                            Graphics2D g2d = image.createGraphics();

                            g2d.setColor(ovalColor);

                            // 填充一个椭圆形

                            g2d.fillOval(x, y, width, height);

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (IOException e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 画一组(多个)点---- 实际上是画一组(多个)填充颜色的圆 ---- 以指定点坐标为中心画一个小半径的圆形,并填充其颜色来充当点

          *

          * @param srcImagePath

          *            原图片路径

          * @param pointList

          *            点列表

          * @param width

          *            宽度

          * @param height

          *            高度

          * @param ovalColor

          *            填充颜色

          * @param imageFormat

          *            写入图片颜色

          * @param toPath

          *            写入路径

          * @throws IOException

          */

         public void drawPoints(String srcImagePath, List pointList, int width,

                            int height, Color ovalColor, String imageFormat, String toPath)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取源图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制连接线

                            Graphics2D g2d = image.createGraphics();

                            g2d.setColor(ovalColor);

                            // 填充一个椭圆形

                            if (pointList != null) {

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

                                               Point point = (Point) pointList.get(i);

                                               int x = (int) point.getX();

                                               int y = (int) point.getY();

                                               g2d.fillOval(x, y, width, height);

                                     }

                            }

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (IOException e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 画线段

          *

          * @param srcImagePath

          *            源图片路径

          * @param x1

          *            第一个点x坐标

          * @param y1

          *            第一个点y坐标

          * @param x2

          *            第二个点x坐标

          * @param y2

          *            第二个点y坐标

          * @param lineColor

          *            线条颜色

          * @param toPath

          *            图像写入路径

          * @param imageFormat

          *            图像写入格式

          * @throws IOException

          */

         public void drawLine(String srcImagePath, int x1, int y1, int x2, int y2,

                            Color lineColor, String toPath, String imageFormat)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取源图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制连接线

                            Graphics2D g2d = image.createGraphics();

                            g2d.setColor(lineColor);

                            g2d.drawLine(x1, y1, x2, y2);

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (IOException e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 画折线 / 线段 ---- 2个点即画线段,多个点画折线

          *

          * @param srcImagePath

          *            源图片路径

          * @param xPoints

          *            x坐标数组

          * @param yPoints

          *            y坐标数组

          * @param nPoints

          *            点的数量

          * @param lineColor

          *            线条颜色

          * @param toPath

          *            图像写入路径

          * @param imageFormat

          *            图片写入格式

          * @throws IOException

          */

         public void drawPolyline(String srcImagePath, int[] xPoints, int[] yPoints,

                            int nPoints, Color lineColor, String toPath, String imageFormat)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取源图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制连接线

                            Graphics2D g2d = image.createGraphics();

                            // 设置线条颜色

                            g2d.setColor(lineColor);

                            g2d.drawPolyline(xPoints, yPoints, nPoints);

                            // 图像写出路径

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (IOException e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 绘制折线,并突出显示转折点

          *

          * @param srcImagePath

          *            源图片路径

          * @param xPoints

          *            x坐标数组

          * @param yPoints

          *            y坐标数组

          * @param nPoints

          *            点的数量

          * @param lineColor

          *            连线颜色

          * @param width

          *            点的宽度

          * @param height

          *            点的高度

          * @param ovalColor

          *            点的填充颜色

          * @param toPath

          *            图像写入路径

          * @param imageFormat

          *            图像写入格式

          * @throws IOException

          */

         public void drawPolylineShowPoints(String srcImagePath, int[] xPoints,

                            int[] yPoints, int nPoints, Color lineColor, int width, int height,

                            Color ovalColor, String toPath, String imageFormat)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取源图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制连接线

                            Graphics2D g2d = image.createGraphics();

                            // 设置线条颜色

                            g2d.setColor(lineColor);

                            // 画线条

                            g2d.drawPolyline(xPoints, yPoints, nPoints);

                            // 设置圆点颜色

                            g2d.setColor(ovalColor);

                            // 画圆点

                            if (xPoints != null) {

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

                                               int x = xPoints[i];

                                               int y = yPoints[i];

                                              g2d.fillOval(x, y, width, height);

                                     }

                            }

                            // 图像写出路径

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                   } catch (IOException e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                  }

         }

 

         /**

          * 绘制一个由 x y 坐标数组定义的闭合多边形

          *

          * @param srcImagePath

          *            源图片路径

          * @param xPoints

          *            x坐标数组

          * @param yPoints

          *            y坐标数组

          * @param nPoints

          *            坐标点的个数

          * @param polygonColor

          *            线条颜色

          * @param imageFormat

          *            图像写入格式

          * @param toPath

          *            图像写入路径

          * @throws IOException

          */

         public void drawPolygon(String srcImagePath, int[] xPoints, int[] yPoints,

                            int nPoints, Color polygonColor, String imageFormat, String toPath)

                            throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制闭合多边形

                            Graphics2D g2d = image.createGraphics();

                            g2d.setColor(polygonColor);

                            g2d.drawPolygon(xPoints, yPoints, nPoints);

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                            g2d.dispose();

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         /**

          * 绘制并填充多边形

          *

          * @param srcImagePath

          *            源图像路径

          * @param xPoints

          *            x坐标数组

          * @param yPoints

          *            y坐标数组

          * @param nPoints

          *            坐标点个数

          * @param polygonColor

          *            多边形填充颜色

          * @param alpha

          *            多边形部分透明度

          * @param imageFormat

          *            写入图形格式

          * @param toPath

          *            写入图形路径

          * @throws IOException

          */

         public void drawAndAlphaPolygon(String srcImagePath, int[] xPoints,

                            int[] yPoints, int nPoints, Color polygonColor, float alpha,

                            String imageFormat, String toPath) throws IOException {

                   FileOutputStream fos = null;

                   try {

                            // 获取图片

                            BufferedImage image = ImageIO.read(new File(srcImagePath));

                            // 根据xy点坐标绘制闭合多边形

                            Graphics2D g2d = image.createGraphics();

                            g2d.setColor(polygonColor);

                            // 设置透明度

                            AlphaComposite ac = AlphaComposite.getInstance(

                                               AlphaComposite.SRC_OVER, alpha);

                            g2d.setComposite(ac);

                            g2d.fillPolygon(xPoints, yPoints, nPoints);

                            fos = new FileOutputStream(toPath);

                            ImageIO.write(image, imageFormat, fos);

                            g2d.dispose();

                   } catch (Exception e) {

                            e.printStackTrace();

                   } finally {

                            if (fos != null) {

                                     fos.close();

                            }

                   }

         }

 

         public static void main(String[] args) throws Exception {

                   OperateImage imageObj = new OperateImage();

 

                   String srcPath = "G:/dm/pic/1.JPG";

                   String toPath = "G:/dm/pic/10.JPG";

                   // imageObj.reduceImageByRatio(srcPath, toPath, 2, 1);// 按指定长和宽的比例缩小图形

                   // int ratio = imageObj.getImgRatio(srcPath,180);

                   imageObj.reduceImageEqualProportion(srcPath, toPath, 2);

                   // imageObj.enlargementImageByRatio(srcPath, toPath, 2, 2);//

                   // 按指定长和宽的比例放大图形

                   // imageObj.enlargementImageEqualProportion(srcPath, toPath, 2);//

                   // 长高等比例放大

                   // imageObj.resizeImage(srcPath, toPath, 400, 400);// 按指定的长宽重置图形大小

 

                   // imageObj.mergeBothImage(negativeImagePath, additionImagePath, x, y,

                   // toPath); //按指定坐标合并图片

 

                   /*

                    * int x = 233; int y = 201; int width = 166; int height = 166 ; String

                    * readImageFormat = "jpg"; String writeImageFormat = "jpg";

                    *

                    * imageObj.cropImage(srcPath, toPath, x, y, width,

                    * height,readImageFormat,writeImageFormat);//剪切图片

                    */

                   // imageObj.resizeImage(srcPath, toPath, 400, 400);//按指定的长宽重置图形大小

                   // imageObj.reduceImageByRatio(srcPath, toPath, 3, 3);//按指定长和宽的比例缩小图形

                   // imageObj.enlargementImageByRatio(srcPath, toPath, 2,

                   // 2);//按指定长和宽的比例放大图形

                   // imageObj.reduceImageEqualProportion(srcPath, toPath, 4);//长高等比例缩小

                   // imageObj.enlargementImageEqualProportion(srcPath, toPath,

                   // 2);//长高等比例放大

                   /*

                    * String negativeImagePath = "D:/test/fileSource/004.jpg"; String

                    * additionImagePath = "D:/test/fileSource/005.jpg"; int x = 200; int y

                    * = 200; String toPath = "D:/test/desk/004+005-rightcenter.jpg";

                    */

                   // imageObj.mergeBothImage(negativeImagePath, additionImagePath, x, y,

                   // toPath); //按指定坐标合并图片

                   // imageObj.mergeBothImageTopleftcorner(negativeImagePath,

                   // additionImagePath, toPath);//合并到左上角

                   // imageObj.mergeBothImageToprightcorner(negativeImagePath,

                   // additionImagePath, toPath);//合并到右上角

                   // imageObj.mergeBothImageLeftbottom(negativeImagePath,

                   // additionImagePath, toPath);//合并到左下角

                   // imageObj.mergeBothImageRightbottom(negativeImagePath,

                   // additionImagePath, toPath);//合并到右下角

                   // imageObj.mergeBothImageCenter(negativeImagePath, additionImagePath,

                   // toPath);//合并到正中央

                   // imageObj.mergeBothImageTopcenter(negativeImagePath,

                   // additionImagePath, toPath);//合并到上边中央

                   // imageObj.mergeBothImageBottomcenter(negativeImagePath,

                   // additionImagePath, toPath);//合并到下边中央

                   // imageObj.mergeBothImageLeftcenter(negativeImagePath,

                   // additionImagePath, toPath);//合并到左边中央

                   // imageObj.mergeBothImageRightcenter(negativeImagePath,

                   // additionImagePath, toPath);//合并到右边中央

 

                   /*

                    * String srcImage = "D:/test/fileSource/001.jpg"; String toPath =

                    * "D:/test/desk/001-gray.jpg"; String imageFormat = "jpg";

                    * imageObj.grayImage(srcImage, toPath, imageFormat);//图片灰化

                    */

 

                   /*

                    * String firstSrcImagePath = "D:/test/desk/003.jpg"; String

                    * secondSrcImagePath = "D:/test/desk/004.jpg"; String imageFormat =

                    * "jpg"; String toPath = "D:/test/desk/003-004-join.jpg";

                    * imageObj.joinImagesHorizontal(firstSrcImagePath, secondSrcImagePath,

                    * imageFormat, toPath);//横向拼接图片

                    */

 

                   /*

                    * String firstSrcImagePath = "D:/test/desk/001-002-join.jpg"; String

                    * secondSrcImagePath = "D:/test/desk/003-004-join.jpg"; String

                    * imageFormat = "jpg"; String toPath = "D:/test/desk/all-join.jpg";

                    * imageObj.joinImagesVertical(firstSrcImagePath, secondSrcImagePath,

                    * imageFormat, toPath);//纵向拼接图片

                    */

 

                   /*

                    * String srcImagePath = "D:/test/fileSource/002.jpg"; int[] xPoints =

                    * {20,100,160,270,500}; int[] yPoints = {30,150,172,295,615}; int

                    * nPoints = 5; String toPath = "D:/test/desk/polygon-002.png";

                    * imageObj.drawPolygon(srcImagePath, xPoints, yPoints, nPoints,

                    * Color.MAGENTA, "jpg", toPath); //根据坐标数组绘制多边形

                    */

 

                   /*

                    * String srcImagePath = "D:/test/fileSource/004.jpg"; String

                    * appendImagePath = "D:/test/fileSource/005.jpg"; float alpha = 0.2F;

                    * String font = "宋体"; int fontStyle = Font.PLAIN; int fontSize = 32;

                    * Color color = Color.RED; String inputWords =

                    * "图片上设置水印文字 ---- 宋体 普通字体 32号字 红色 透明度0.5"; int x = 20; int y = 40;

                    * String imageFormat = "jpg"; String toPath =

                    * "D:/test/desk/alphaI2I-001.png";

                    */

                   // imageObj.alphaWords2Image(srcImagePath, alpha, font, fontStyle,

                   // fontSize, color, inputWords, x, y, imageFormat, toPath); //设置文字水印

                   // imageObj.alphaImage2Image(srcImagePath, appendImagePath, alpha, x, y,

                   // 300, 200, imageFormat, toPath);//设置图片水印

 

                   /*

                    * String srcImagePath = "D:/test/fileSource/003.jpg"; int[] xPoints =

                    * {100,150,200,240,300}; int[] yPoints = {200,60,280,160,100}; int

                    * nPoints = 5; Color lineColor = Color.RED; String toPath =

                    * "D:/test/desk/polyline-003.jpg"; String imageFormat = "jpg";

                    * imageObj.drawPolyline(srcImagePath, xPoints, yPoints, nPoints,

                    * lineColor,toPath, imageFormat);//画折线

                    */

 

                   /*

                    * int x1 = 50; int y1 = 100; int x2 = 600; int y2 = 150; Color

                    * lineColor = Color.BLUE; imageObj.drawLine(srcImagePath, x1, y1, x2,

                    * y2, lineColor,toPath, imageFormat);//画线段

                    */

 

                   /*

                    * String srcImagePath = "D:/test/fileSource/002.jpg"; int x = 400; int

                    * y = 500; int width = 10; int height = 10; Color ovalColor =

                    * Color.RED; String imageFormat = "jpg"; String toPath =

                    * "D:/test/desk/point-002.jpg"; imageObj.drawPoint(srcImagePath, x, y,

                    * width, height, ovalColor, imageFormat, toPath);//画一个圆点

                    */

 

                   /*

                    * List pointList = new ArrayList(); Point p1 = new Point(60,80);

                    * pointList.add(p1); Point p2 = new Point(160,80); pointList.add(p2);

                    * Point p3 = new Point(60,180); pointList.add(p3); Point p4 = new

                    * Point(260,180); pointList.add(p4); Point p5 = new Point(460,380);

                    * pointList.add(p5); String srcImagePath =

                    * "D:/test/fileSource/004.jpg"; int width = 10; int height = 10; Color

                    * ovalColor = Color.RED; String imageFormat = "jpg"; String toPath =

                    * "D:/test/desk/points-004.jpg"; imageObj.drawPoints(srcImagePath,

                    * pointList, width, height, ovalColor, imageFormat, toPath);//画出一组(多个)点

                    */

 

                   /*

                    * int[] xPoints = {50,100,180,400,600}; int[] yPoints =

                    * {200,100,160,300,640}; int nPoints = 5; Color lineColor = Color.PINK;

                    * String srcImagePath = "D:/test/fileSource/003.jpg"; String toPath =

                    * "D:/test/desk/showpoints-003.jpg";

                    * imageObj.drawPolylineShowPoints(srcImagePath, xPoints, yPoints,

                    * nPoints, lineColor, width, height, ovalColor, toPath,

                    * imageFormat);//画折线并突出显示点

                    */

 

                   /*

                    * String srcImagePath ="D:/test/fileSource/004.jpg"; int[] xPoints

                    * ={50,90,180,320,640}; int[] yPoints ={200,300,120,240,360}; int

                    * nPoints = 5; Color polygonColor = Color.PINK; float alpha = (float)

                    * 0.2; String imageFormat ="jpg"; String toPath

                    * ="D:/test/desk/drawalpha-004.jpg";

                    * imageObj.drawAndAlphaPolygon(srcImagePath, xPoints, yPoints, nPoints,

                    * polygonColor, alpha, imageFormat, toPath);

                    */

                   /*

                    * String negativeImagePath = "D:/test/fileSource/001.jpg"; String

                    * additionImagePath = "D:/test/fileSource/006.png"; String toPath =

                    * "D:/test/fileSource/001.jpg"; long start =

                    * System.currentTimeMillis(); for(int i=0;i<1000;i++){ Random rand =

                    * new Random(); int x = rand.nextInt(1024); int y = rand.nextInt(768);

                    * imageObj.mergeBothImage(negativeImagePath, additionImagePath, x, y,

                    * toPath);//每次附加合并一张图片(循环若干次) } long end = System.currentTimeMillis();

                    * System.out.println(end-start);

                    */

                   // 100 -- 45844

                   // 1000 -- 411156

                   /*

                    * 改进思路:将mergeBothImage方法 修改为mergeImageList方法,

                    * 通过将图片的坐标点装入list容器,然后再取出一来在方法中一次性与图片合并, 不再每次都打开底图、保存合成图片,关闭流

                    */

 

                   // 叠加组合图像

                   /*

                    * String negativeImagePath = "D:/test/fileSource/001.jpg"; String

                    * toPath = "D:/test/fileSource/001.jpg"; String additionImagePath =

                    * "D:/test/fileSource/007.png"; List additionImageList = new

                    * ArrayList(); int count = 0; for(int

                    * i=0;i<100;i++){//为什么总是连续生成一样的随机数??? Random rand = new Random(); int x

                    * = rand.nextInt(1020); String xStr = x+""; int y = rand.nextInt(760);

                    * String yStr = y +""; String[] str = {xStr,yStr,additionImagePath};

                    * additionImageList.add(str); count++;

                    * //System.out.println(xStr+"   :     "+yStr); }

                    * System.out.println(count); long start = System.currentTimeMillis();

                    * imageObj.mergeImageList(negativeImagePath, additionImageList,"jpg",

                    * toPath); long end = System.currentTimeMillis();

                    * System.out.println(end-start);

                    */

                   // 第一次 第二次 第三次

                   // 100张耗时(毫秒) --2003 1792 1869 1747 1871 1793

                   // 1000张耗时(毫秒) --15334 15200 15236 15903 16028 15545

                   // 10000张耗时(毫秒) --153010 153340 152673 154978 156506 154854

                   // 如果list.size()<=100,则调用此方法,

                   // 如果list.size()>100,则调用Jmagick的方法。

 

                   /*

                    * List iamgePathList = new ArrayList(); // D:/test/16a/

                    * iamgePathList.add("D:/test/16a/12384_2492.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2493.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2494.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2495.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2496.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2497.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2498.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2499.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2500.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2501.jpg");

                    * iamgePathList.add("D:/test/16a/12384_2502.jpg");

                    */

                   // String imageFormat = "jpg";

                   // String toPath = "D:/test/desk/16a_v1.jpg";

                   // imageObj.joinImageListHorizontal(iamgePathList, imageFormat, toPath);

 

                   /*

                    * String imageFormat = "jpg"; String[] pics1 =

                    * {"D:/test/16a/12384_2502.jpg","D:/test/16a/12384_2501.jpg",

                    * "D:/test/16a/12384_2500.jpg"

                    * ,"D:/test/16a/12384_2499.jpg","D:/test/16a/12384_2498.jpg",

                    * "D:/test/16a/12384_2497.jpg"

                    * ,"D:/test/16a/12384_2496.jpg","D:/test/16a/12384_2495.jpg",

                    * "D:/test/16a/12384_2494.jpg"

                    * ,"D:/test/16a/12384_2493.jpg","D:/test/16a/12384_2492.jpg"};

                    *

                    * String[] pics2 =

                    * {"D:/test/16a/12385_2502.jpg","D:/test/16a/12385_2501.jpg",

                    * "D:/test/16a/12385_2500.jpg"

                    * ,"D:/test/16a/12385_2499.jpg","D:/test/16a/12385_2498.jpg",

                    * "D:/test/16a/12385_2497.jpg"

                    * ,"D:/test/16a/12385_2496.jpg","D:/test/16a/12385_2495.jpg",

                    * "D:/test/16a/12385_2494.jpg"

                    * ,"D:/test/16a/12385_2493.jpg","D:/test/16a/12385_2492.jpg"};

                    *

                    * String[] pics3 =

                    * {"D:/test/16a/12386_2502.jpg","D:/test/16a/12386_2501.jpg",

                    * "D:/test/16a/12386_2500.jpg"

                    * ,"D:/test/16a/12386_2499.jpg","D:/test/16a/12386_2498.jpg",

                    * "D:/test/16a/12386_2497.jpg"

                    * ,"D:/test/16a/12386_2496.jpg","D:/test/16a/12386_2495.jpg",

                    * "D:/test/16a/12386_2494.jpg"

                    * ,"D:/test/16a/12386_2493.jpg","D:/test/16a/12386_2492.jpg"};

                    *

                    * String[] pics4 =

                    * {"D:/test/16a/12387_2502.jpg","D:/test/16a/12387_2501.jpg",

                    * "D:/test/16a/12387_2500.jpg"

                    * ,"D:/test/16a/12387_2499.jpg","D:/test/16a/12387_2498.jpg",

                    * "D:/test/16a/12387_2497.jpg"

                    * ,"D:/test/16a/12387_2496.jpg","D:/test/16a/12387_2495.jpg",

                    * "D:/test/16a/12387_2494.jpg"

                    * ,"D:/test/16a/12387_2493.jpg","D:/test/16a/12387_2492.jpg"};

                    *

                    * String[] pics5 =

                    * {"D:/test/16a/12388_2502.jpg","D:/test/16a/12388_2501.jpg",

                    * "D:/test/16a/12388_2500.jpg"

                    * ,"D:/test/16a/12388_2499.jpg","D:/test/16a/12388_2498.jpg",

                    * "D:/test/16a/12388_2497.jpg"

                    * ,"D:/test/16a/12388_2496.jpg","D:/test/16a/12388_2495.jpg",

                    * "D:/test/16a/12388_2494.jpg"

                    * ,"D:/test/16a/12388_2493.jpg","D:/test/16a/12388_2492.jpg"};

                    *

                    * String[] pics6 =

                    * {"D:/test/16a/12389_2502.jpg","D:/test/16a/12389_2501.jpg",

                    * "D:/test/16a/12389_2500.jpg"

                    * ,"D:/test/16a/12389_2499.jpg","D:/test/16a/12389_2498.jpg",

                    * "D:/test/16a/12389_2497.jpg"

                    * ,"D:/test/16a/12389_2496.jpg","D:/test/16a/12389_2495.jpg",

                    * "D:/test/16a/12389_2494.jpg"

                    * ,"D:/test/16a/12389_2493.jpg","D:/test/16a/12389_2492.jpg"};

                    *

                    * String toPath1 = "D:/test/desk/16a_v1.jpg"; String toPath2 =

                    * "D:/test/desk/16a_v2.jpg"; String toPath3 =

                    * "D:/test/desk/16a_v3.jpg"; String toPath4 =

                    * "D:/test/desk/16a_v4.jpg"; String toPath5 =

                    * "D:/test/desk/16a_v5.jpg"; String toPath6 =

                    * "D:/test/desk/16a_v6.jpg";

                    *

                    * String[] pics7 = {toPath1,toPath2,toPath3,toPath4,toPath5,toPath6};

                    * String toPath7 = "D:/test/desk/16a_h1.jpg";

                    *

                    * long start = System.currentTimeMillis();

                    * imageObj.joinImageListVertical(pics1, imageFormat, toPath1);

                    * imageObj.joinImageListVertical(pics2, imageFormat, toPath2);

                    * imageObj.joinImageListVertical(pics3, imageFormat, toPath3);

                    * imageObj.joinImageListVertical(pics4, imageFormat, toPath4);

                    * imageObj.joinImageListVertical(pics5, imageFormat, toPath5);

                    * imageObj.joinImageListVertical(pics6, imageFormat, toPath6);

                    *

                    * imageObj.joinImageListHorizontal(pics7, imageFormat, toPath7); long

                    * end = System.currentTimeMillis(); System.out.println(end-start);

                    */

 

         }

}

来自:http://blog.csdn.net/tototuzuoquan/article/details/48354387

扩展阅读

SpringMVC结合Jcrop实现头像上传功能!头像上传以及之前预览再以及剪裁
使用jcrop进行头像剪切
JAVA实现图片剪切缩放功能
Web端裁剪图片方法
头像裁剪组件jcrop基本用法

为您推荐

使用 HTTP 上传 G 级的文件之 Node.js 版本
非常实用的CSS使用技巧
基于 canvas 将图片转化成字符画
html5 audio音频播放全解析
jQuery Validate 表单验证

更多

JCrop
JavaScript开发工具包
相关文档  — 更多
相关经验  — 更多
相关讨论  — 更多