sanshizi
- 浏览: 85530 次
- 性别:
- 来自: 南京
-
文章分类
最新评论
-
cl1154781231：
怎么解决？
Node cannot be inserted at the specified point in the hierarchy -
sanshizi：
1927105 写道写文档的能力有待提高啊现在如何
一个下拉菜单效果的实现 -
sanshizi：
jacking124 写道看着不是很明白的加入了说明
一个下拉菜单效果的实现 -
sanshizi：
Chris_bing 写道有Jackson，Gson，json ...
将java类生成json -
Chris_bing：
有Jackson，Gson，json-smart那么多类库，干 ...
将java类生成json
package com.adam.dev.pic.easyImage;
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.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
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 com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGImageEncoder;
/**
* @author adam.胡升阳
* 创建日期 2012-2-29
*/
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);
}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 = 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);
}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);
}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);
}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);
}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();
}
}
}
public static void main(String[] args)throws Exception{
OperateImage imageObj = new OperateImage();
/*String srcPath = "D:/test/fileSource/004.jpg";
String toPath = "D:/test/desk/+e004.jpg";
int x = 200;
int y = 300;
int width = 300;
int height = 200 ;
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);*/
String str = "北京\n上海\n广州\n深圳";
System.out.println(str);
String path = "c:/relevantdata.txt";
FileOutputStream fops = new FileOutputStream(path);
fops.write(str.getBytes());
BufferedReader inputStream = new BufferedReader(new FileReader(new File(path)));
String mrMsg = "";
while((mrMsg = inputStream.readLine())!=null){
System.out.println(mrMsg);
}
}
//数量 11 11x6
//纵向 375
//横向 391 3250
}
分享到：
发表评论
-
java 放大镜效果
2013-06-13 10:21 2947坛里看到, 备忘一下 这里用到第三方库, 主要是做高斯模糊用的 ... -
分享一个play framework的DuplicateMemberException冲突
2013-05-17 09:48 3198分享一个play framework的DuplicateMem ... -
将java类生成json
2012-10-21 22:20 3782package utils; import java ... -
nutz创建表报错
2012-06-16 12:48 1922偶用nutz创建表, 报如下错, DataSource 可 ... -
用java读取svn数据, oh yeah
2012-06-12 15:02 1772用java读取svn数据, 请猛击此处 Aut ... -
[转]Java 数字签名（Digital Signature）的批处理文件制作
2012-06-02 15:59 1264出处: http://blog.csdn.net/casula ...
相关推荐
java 图片处理 切图代码 实现自动缩放图片
在java中通过ImageMagick安装包和im4java.jar把其他格式图片如HEIC转换为PNG，JPEG等常用格式图片。内有安装操作步骤及编码内容。亲测有效。 场景运用：ios操作系统在前端图片格式上传中。已普遍采用HEIC格式图片。...
这是一个Java图片处理程序。 Java 开源代码，高手学习 java 图片处理源码
Java图片处理工具ImageMagick是一个强大的跨平台图形处理库，它允许开发人员在Java应用程序中进行复杂的图像操作，包括但不限于转换、编辑、合成图像以及处理大量格式的图像文件。ImageMagick是由C语言编写的，但...
在Java编程语言中，处理图像是一项常见的任务，包括图片的旋转、翻转和镜像操作。...在实际应用中，根据需求，你可以结合其他图像处理技术，如颜色空间转换、滤波器等，进一步增强图片处理的能力。
使用这个工具包，开发者可以在Java环境中轻松地处理Excel转图片的需求，无需依赖第三方应用或服务，提高了开发效率和项目的自给自足性。同时，纯Java实现保证了跨平台的兼容性，可以在各种Java运行环境中稳定工作。
如果是测试用例，通常会包含调用图片处理函数并验证结果的测试方法。 为了实现这些功能，Java开发者还需要理解基本的图像处理概念，如像素、颜色模型（RGB、CMYK等）以及图像的宽度和高度。同时，熟悉流的概念也很...
在标签中，作者列出了四个关键词：“java 处理图片背景颜色”、“java 图片背景颜色替换”、“java 图片背景颜色更改”、“java 蓝底寸照批量转换为白底”，这些关键词都与 Java 处理图片背景颜色相关。 在部分内容...
在实际项目开发中，图片处理是一项常见的需求，包括但不限于图片的压缩、尺寸调整以及添加水印等操作。传统的Java库虽然能够实现这些功能，但往往在图片质量方面不尽如人意，尤其是当图片尺寸被大幅度压缩时，画质...
本项目主要涉及的是如何在Java环境中将图片转换为WebP格式，这是一种由Google开发的高效图像文件格式，旨在提供更好的压缩效率，同时保持图像质量。下面我们将深入探讨这个Java Maven项目中的关键技术点。 首先，...
3. **其他库**: 还有一些其他的Java库，如Html2Image、Awesomium等，它们也提供了类似的功能。选择哪个库取决于你的具体需求，如性能、易用性、兼容性等因素。 无论你选择哪种方法，确保你处理了可能的异常，并且...
这个程序不仅可以用来下载单一图片，还可以作为基础框架扩展成更复杂的应用，如批量下载图片、图片处理等功能。此外，该程序还提供了一个基本的网络通信示例，有助于理解Java中的网络编程技术。
【标题】"图片处理程序JAVA源代码"是一个适合初学者的项目，旨在通过实际操作来教授Java编程的基础知识，特别是与图像处理相关的技术。在Java中处理图片涉及到多个类库和概念，例如Java的`java.awt`和`javax.imageio...
Java图像处理类库，如Java Image Filters，是Java平台上的一个重要工具，用于对数字图像进行各种操作和修改。这些类库通常包含了一系列的类和方法，可以实现图像的过滤、调整、裁剪、旋转、合成等多种功能，为开发者...
这个项目是使用Java编程语言实现的，通过分析标题"转盘旋转抽奖用java代码的实现"和描述"该资源里面有项目做出来的效果图，解压就可以看到，当指针指向任意区域的奖项，都会有个弹窗提示几等奖"，我们可以推测出以下...
除了Java 2D API，还有一些第三方库，如Apache Commons Imaging (formerly Sanselan) 和 ImageMagick，它们提供了更强大的图片处理功能，包括更高级的压缩算法和更灵活的参数调整。 在实际开发中，你可能需要根据...
Java作为后端语言，处理这种情况时需要与前端协同工作，确保用户上传的图片能正确显示。本文将详细阐述如何在前后台解决图片旋转问题。 ### 前端处理 前端处理主要涉及到图片预览和上传前的旋转操作。当用户通过...
这个实例代码将向我们展示如何使用Java的Graphics2D类来实现图片的旋转。Graphics2D是Java 2D API的一部分，提供了丰富的绘图和图形操作功能，包括旋转、缩放、平移等。 首先，我们需要了解Java中的`BufferedImage`...
在Java编程语言中，处理...综上所述，这段代码展示了Java如何利用AWT库进行图片处理，包括添加图片和文字水印，以及处理透明度和定位。这些都是Java图形处理的基本技术，对于开发涉及图像编辑和处理的应用非常有用。
本项目“java将word转图片转pdf_jacob.zip”是关于利用Java进行文档格式转换的一个实例，主要涉及的技术点包括Java与Microsoft Office文档的交互以及图片和PDF的生成。 首先，我们需要了解Java中的Jacob库。Jacob...