java ImageIO处理图像的封装

最新推荐文章于 2023-04-17 00:09:53 发布
狮子心2012
最新推荐文章于 2023-04-17 00:09:53 发布
阅读量453
点赞数
分类专栏： java 文章标签：图像处理 java
java 专栏收录该内容
11 篇文章 0 订阅
订阅专栏
转自：http://blog.csdn.net/hu_shengyang/article/details/7433988
直接给代码：
[java]view plaincopy 
   
 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 ImageIO处理图形的一些常用的方法进行的封装。全部测试通过，main方法中的均为测试代码，如果想用这个图像处理类，可以参考mian方法的例子。
另外代码中有些地方需要改进，效率也需要进一步提高。
希望给大家带来方便~
狮子心2012
关注
0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java ImageIO处理图像的封装

转自：http://blog.csdn.net/hu_shengyang/article/details/7433988直接给代码：[java] view plaincopypackage com.adam.dev.pic.easyImage; import java.awt.AlphaComposite; import
复制链接

扫一扫