Java实现图片操作：切割、缩放、重置、拼接、合并、水印、画单点、画线段等 ... ...

2024-6-5 22:56| 发布者: zhaojun917| 查看: 298| 评论: 0

摘要: 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.Colo ...

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

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 com.sun.image.codec.jpeg.JPEGCodec;

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

/*

* @Param

* @return

* @Description TODO (新增图片格式新增自动识别xywh四点切割原有方法思路不变)

**/

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 bytes 读取图片二进制

* @param position 图片切割位置

* @param readImageFormat 读取图片格式

* @param writeImageFormat 写入图片格式

* @throws IOException

*/

public byte[] cropImage(byte[] bytes,int[] position, String readImageFormat,String writeImageFormat) throws IOException{

FileInputStream fis = null ;

ImageInputStream iis =null ;

InputStream is = null;

ByteArrayOutputStream out=null;

int x=position[0];

int y=position[1];

int width=position[2];

int height=position[3];

try{

//读取图片文件

//fis = new FileInputStream();

is = new ByteArrayInputStream(bytes);

Iterator it = ImageIO.getImageReadersByFormatName(readImageFormat);

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

//获取图片流

iis = ImageIO.createImageInputStream(is);

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

//保存新图片

out = new ByteArrayOutputStream();

ImageIO.write(bi, writeImageFormat, out);

return out.toByteArray();

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

}catch(Exception e){

e.printStackTrace();

}finally{

if(out != null){

out.close();

}

/**

* 长高等比例缩小图片

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

收藏分享邀请

上一篇：java 将两张图片合成一张下一篇：springboot实现文件批量下载(打包下载)

账号		自动登录	找回密码
密码			立即注册

Java实现图片操作：切割、缩放、重置、拼接、合并、水印、画单点、画线段等 ... ...

相关分类

站长推荐 /7