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

2022-04-04 10:03:39

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

案例效果如下：

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

3.编写的html代码如下：

封面截取

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

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

</div>

<img id="jcrop_target"

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

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

</div>

<img id="cutImgId"

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

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

</div>

</div>

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

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

</div>

4编写JS代码（注意这里的280和175表示的是我要一张长为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组件(FileUpload的js组件)

$('#uploadCover').fileupload({

dataType: 'json',

//autoUpload: true,

url:'/contentAffix/upTemp',

done: function (e, data) {

if(jcrop_api!=null){

jcrop_api.destroy();

}

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

if(index=='filedesc') {

//获取文件名称

filename=file.filename;

//实际的文件高度

imgweight = file.imgweight;

//实际的文件宽度

imgheight = file.imgheight;

// //设置缩放比例

// dx = imgweight / displayW;

// dy = imgheight / displayH;

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

// scale = dx;

// }

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

// scale = dy;

// }

// displayW = imgweight / scale;

// displayH = imgheight / scale;

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

// width:displayW + 'px',

// height:displayH + 'px'

// });

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

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

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

// });

originalfilename = file.originalfilename;

fileid=file.id;

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

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

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

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

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

cutPic();

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

//jcrop_api.setImage(imgurl);

}

});

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

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

});

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

}

//点击裁剪时做的操作

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

function saveUploadImg(){

c = jcrop_api.tellSelect();

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

$.ajax({

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

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

dataType:'json',

success: function(data){

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

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

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

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

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

displayW = 280;

displayH = 350;

}else{

alert("请选择图片");

}

});

}

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

function saveReuploadImg(){

c = jcrop_api.tellSelect();

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

$.ajax({

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

data :{

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

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

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

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

"filename":filename,

"fileid":fileid,

"originalfilename":originalfilename,

"affixId":affixId

dataType:'json',

success: function(data){

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

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

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

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

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

}else{

alert("请选择图片");

}

});

}

//显示预览

function showPreview(c){

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

var rx = 280 / c.w;

var ry = 175 / c.h;

var bounds = jcrop_api.getBounds();

boundx = bounds[0];

boundy = bounds[1];

$('#cutImgId').css({

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

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

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

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

});

}

function cutPic(){

imgObj = new Image();

imgObj.src = jcrop_target.src;

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

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

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

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

drawBorders:false,//绘制边框

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

allowResize:true,

allowSelect:false, //允许新选框

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

// minSize: [50,50],

// allowMove: true,

// allowResize:false,

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

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

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

// handleSize:9,

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

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

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

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

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

// aspectRatio:1, //正方形

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

});

//设置选择框默认位置

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

};

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;

}

/**

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

* @param negativeImagePath

* 背景图片路径

* @param additionImagePath

* 附加图片路径

* @param x

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

* @param y

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

* @param toPath

* 图片写入路径

* @throws IOException

public void mergeBothImage(String negativeImagePath,

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

throws IOException {

InputStream is = null;

InputStream is2 = null;

// OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

is2 = new FileInputStream(additionImagePath);

BufferedImage image = ImageIO.read(is);

BufferedImage image2 = ImageIO.read(is2);

Graphics g = image.getGraphics();

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

// os = new FileOutputStream(toPath);

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

// enc.encode(image);

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

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

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

} catch (Exception e) {

e.printStackTrace();

} finally {

// if (os != null) {

// os.close();

// }

if (is2 != null) {

is2.close();

}

if (is != null) {

is.close();

}

/**

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

* @param negativeImagePath

* 源图像（底图）路径

* @param additionImageList

* 附加图像信息列表

* @param imageFormat

* 图像写入格式

* @param toPath

* 图像写入路径

* @throws IOException

public void mergeImageList(String negativeImagePath,

List additionImageList, String imageFormat, String toPath)

throws IOException {

InputStream is = null;

InputStream is2 = null;

OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

BufferedImage image = ImageIO.read(is);

// Graphics g=image.getGraphics();

Graphics2D g = image.createGraphics();

;

BufferedImage image2 = null;

if (additionImageList != null) {

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

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

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

String[] additionImageInfo = (String[]) additionImageList

.get(i);

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

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

String additionImagePath = additionImageInfo[2];

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

is2 = new FileInputStream(additionImagePath);

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

image2 = ImageIO.read(is2);

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

}

os = new FileOutputStream(toPath);

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

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

// enc.encode(image);

} catch (Exception e) {

e.printStackTrace();

} finally {

if (os != null) {

os.close();

}

if (is2 != null) {

is2.close();

}

if (is != null) {

is.close();

}

/**

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

* @param negativeImagePath

* 底图路径

* @param additionImagePath

* 附加图片路径

* @param toPath

* 合成图片写入路径

* @throws IOException

public void mergeBothImageTopleftcorner(String negativeImagePath,

String additionImagePath, String toPath) throws IOException {

InputStream is = null;

InputStream is2 = null;

// OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

is2 = new FileInputStream(additionImagePath);

BufferedImage image = ImageIO.read(is);

BufferedImage image2 = ImageIO.read(is2);

Graphics g = image.getGraphics();

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

// os = new FileOutputStream(toPath);

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

// enc.encode(image);

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

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

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

} catch (Exception e) {

e.printStackTrace();

} finally {

// if (os != null) {

// os.close();

// }

if (is2 != null) {

is2.close();

}

if (is != null) {

is.close();

}

/**

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

* @param negativeImagePath

* 底图路径

* @param additionImagePath

* 附加图片路径

* @param toPath

* 合成图片写入路径

* @throws IOException

public void mergeBothImageToprightcorner(String negativeImagePath,

String additionImagePath, String toPath) throws IOException {

InputStream is = null;

InputStream is2 = null;

// OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

is2 = new FileInputStream(additionImagePath);

BufferedImage image = ImageIO.read(is);

BufferedImage image2 = ImageIO.read(is2);

Graphics g = image.getGraphics();

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

// os = new FileOutputStream(toPath);

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

// enc.encode(image);

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

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

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

} catch (Exception e) {

e.printStackTrace();

} finally {

// if (os != null) {

// os.close();

// }

if (is2 != null) {

is2.close();

}

if (is != null) {

is.close();

}

/**

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

* @param negativeImagePath

* 底图路径

* @param additionImagePath

* 附加图片路径

* @param toPath

* 合成图片写入路径

* @throws IOException

public void mergeBothImageLeftbottom(String negativeImagePath,

String additionImagePath, String toPath) throws IOException {

InputStream is = null;

InputStream is2 = null;

// OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

is2 = new FileInputStream(additionImagePath);

BufferedImage image = ImageIO.read(is);

BufferedImage image2 = ImageIO.read(is2);

Graphics g = image.getGraphics();

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

// os = new FileOutputStream(toPath);

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

// enc.encode(image);

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

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

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

} catch (Exception e) {

e.printStackTrace();

} finally {

// if (os != null) {

// os.close();

// }

if (is2 != null) {

is2.close();

}

if (is != null) {

is.close();

}

/**

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

* @param negativeImagePath

* 底图路径

* @param additionImagePath

* 附加图片路径

* @param toPath

* 合成图片写入路径

* @throws IOException

public void mergeBothImageRightbottom(String negativeImagePath,

String additionImagePath, String toPath) throws IOException {

InputStream is = null;

InputStream is2 = null;

// OutputStream os = null;

try {

is = new FileInputStream(negativeImagePath);

is2 = new FileInputStream(additionImagePath);

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); // 输入水印文字及其起始x、y坐标

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

}

码农公寓

相关文章