JAVA对图片的操作

最新推荐文章于 2023-02-26 22:49:05 发布
最新推荐文章于 2023-02-26 22:49:05 发布
阅读量518 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ZHANGHUI3239619/article/details/78746852

package org.review;

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


public class OperateImage {

 public OperateImage() {
  super();
 }

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

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

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

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

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

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

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

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

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

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

 
 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);
   System.out.println(image2);
   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();
   }
  }
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 
 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 srcImagePath = "E:/tmp/20130822160831.png";
  //     int[] xPoints = {20,100,160,270,500};
  //     int[] yPoints = {30,150,172,295,615};
  //     int nPoints = 5;
  //     String toPath = "E:/tmp/test.png";
  //     imageObj.drawPolygon(srcImagePath, xPoints, yPoints, nPoints, Color.MAGENTA, "png", 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 = "E:/tmp/20130822160831.png";
  //     int width = 10;
  //     int height = 10;
  //     Color ovalColor = Color.RED;
  //     String imageFormat = "png";
  //     String toPath = "E:/tmp/test1.png";
  //     imageObj.drawPoints(srcImagePath, pointList, width, height, ovalColor, imageFormat, toPath);//画出一组（多个）点

  ;
  //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);//长高等比例放大
  
  //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 = "E:/tmp/20130822160831.png";
  //     String toPath = "E:/tmp/test2.png";
  //     String imageFormat = "png";
  //     imageObj.grayImage(srcImage, toPath, imageFormat);//图片灰化

  //     String firstSrcImagePath = "E:/tmp/20130822160831.png";
  //     String secondSrcImagePath = "E:/tmp/mapimg123.png";
  //     String imageFormat = "png";
  //     String toPath = "E:/tmp/test5.png";
  //     //imageObj.joinImagesHorizontal(firstSrcImagePath, secondSrcImagePath, imageFormat, toPath);//横向拼接图片
  //     imageObj.joinImagesHorizontal(firstSrcImagePath, secondSrcImagePath, imageFormat, toPath);//横向拼接图片
  

  

  //     String srcImagePath = "E:/tmp/20130822160831.png";
  //     String appendImagePath = "E:/tmp/20130822160848.png";
  //     float alpha = 1F;
  //     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 = "E:/tmp/test8.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 = "E:/tmp/20130822160831.png";
  //     int[] xPoints = {100,150,200,240,300};
  //     int[] yPoints = {200,60,280,160,100};
  //     int nPoints = 5;
  //     Color lineColor = Color.RED;
  //     String toPath = "E:/tmp/test7.png";
  //     String imageFormat = "png";
  //     imageObj.drawPolyline(srcImagePath, xPoints, yPoints, nPoints, lineColor,toPath, imageFormat);//画折线

  

  

  //    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 = "E:/tmp/20130822160831.png";
  //     int width = 10;
  //     int height = 10;
  //     Color ovalColor = Color.RED;
  //     String imageFormat = "png";
  //     String toPath = "E:/tmp/test9.png";
  //     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 = "E:/tmp/20130822160831.png";
  //     String toPath = "E:/tmp/test11.png";
  //     imageObj.drawPolylineShowPoints(srcImagePath, xPoints, yPoints, nPoints, lineColor, 10, 10, Color.RED, toPath, "png");//画折线并突出显示点
  //

  //     String srcImagePath ="E:/tmp/20130822160831.png";
  //     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 ="png";
  //     String toPath ="E:/tmp/test12.png";
  //     imageObj.drawAndAlphaPolygon(srcImagePath, xPoints, yPoints, nPoints, polygonColor, alpha, imageFormat, toPath);
  
  //100 -- 45844
  //1000 -- 411156
  

  //叠加组合图像
  
  //                                第一次        第二次      第三次
  //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的方法。
  
  //String imageFormat = "jpg";
  //String toPath = "D:/test/desk/16a_v1.jpg";
  //imageObj.joinImageListHorizontal(iamgePathList, imageFormat, toPath);
  

  //     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 图像相关操作
weixin_40852944的博客
09-09 269
最近工作涉及到图片上传，裁剪，缩放，去背景色相关功能，在此总结一下，供需要学习的同学参考也为自己做一次总结： 1，大概讲一下处理逻辑： 1）用户前端上传一张图片（原图），后端进行图像存储后，返回图像的宽高，及图像预览的地址 controller端方法 public .. imgUpload(MultipartFile img){ //读取图...
Java图片操作详解
li_w_ch的博客
10-30 1724
1、读取图片 常见的有两种方式读取图片： //通过java.awt.Toolkit工具类读取 Image image = Toolkit.getDefaultToolkit().getImage(String filename); Image image = Toolkit.getDefaultToolkit().getImage(URL url); Toolkit.getDefaultToolkit().createImage(byte[] imageData); //通过javax.imagei
java实现对图片的各种操作
08-15
java实现对图片裁剪，并把裁剪新图片保存，按倍率缩小、放大图片，重置图形的边长大小，拼接图片等等操作 使用Java进行图像处理的一些基础操作，java实现对图片的各种操作下载
C#关于对图片的操作
01-30
C#关于对图片的操作(生成缩略图，合并图片，加水印文字与图片，生成电子印章，生成验证码等)
java 图片操作_Java对图片的操作
weixin_32589387的博客
02-16 961
有一天我在做一个游戏的时候听说可以把图片翻转过来可以减少自己做图片的时间 所以我就在网上找了一下 发现很多文章写得特别复杂 并且有一些方法都不能在eclipse上面用，所以我就模仿网上的文章写出适合自己的方法；对图片的操作总体来就是：1。新建一个BufferedImage，Graphics2D2.然后用BufferedImage类中的一个createGraphics方法 来返回一个Graphi...
Java对于图片的操作
周世文的博客
06-08 1339
最近工作上用到图片旋转，所以来偏图片旋转的文章。其中碰到不少坑。以下实现了旋转90度的倍数。方便我们了解旋转是怎么做的 ，如果要旋转任意角度，可以用Java自带的thumbnails（文章后面介绍）import org.springframework.util.Base64Utils; import net.coobird.thumbnailator.Thumbnails; /**
java操作wordpdf图片生成图片水印
05-18
首先，我们关注的是Java对Word文档的操作。Apache POI是一个非常流行的Java库，用于读写Microsoft Office格式的文件，包括Word（.docx）文档。通过使用Apache POI，我们可以打开Word文档，访问其中的图片元素，然后...
Java实现pdf格式图片转换
06-09
在java中通过ImageMagick...在wiondows操作系统java开发环境中可通过ImageMagick安装包和im4java.jar把其他格式图片如pdf转换为PNG，JPEG等常用格式图片。操作其实比较简单。内附有操作步骤及图片转换文件大小的调整。
java图片操作
01-31
java 图片压缩 图片切割
java指纹识别-图片识别技术
04-17
2. **预处理**：对原始指纹图像进行平滑、增强、噪声消除等操作，以便更好地提取特征。 3. **特征提取**：提取指纹的细节特征，如脊线、端点、分叉点等，这些特征用于后续的指纹匹配。 4. **模板生成**：将提取的...
对图片的操作
weixin_42715287的博客
08-06 623
英文原文链接：Operations with images 文章目录输入/输出图像的基本操作内存管理和引用计数基本操作可视化图像 输入/输出 从文件加载一个图像: Mat img = imread(filename); 如果你读取一个jpg文件，默认情况下会创建一个3通道的图像。如果你需要一个灰度图像，使用: Mat img = imread(filename, IMREAD_GRAYSCALE); 文件的格式由它的内容(前几个字节)决定。保存一个图像到一个文件: imwrite(fil
Java使用Thumbnailator压缩图片
-
07-12 883
java对图片的操作 获取图片宽度和高度 /** * 获取图片宽度和高度 * * @param 图片路径 * @return 返回图片的宽度 */ public static int[] getImgWidthHeight(File file) { InputStream is = null; ...
java中图片简单操作
bornonew的博客
07-29 1681
最近做网站时，经常会对图片进行操作，用到的基本操作如下： 1.读取图片到 二进制数组中 ByteArrayOutputStream out = null ; BufferedInputStream in = null; File file = new File(relativePath); in = new BufferedI
生成图片缩略图
06-20 1004
/** * 制作图片缩略图 */ public class PicUtils { private String srcFile; private String destFile; private int width; private int height; private Image img; /** * 构造函数 * @param fileName * @throw
java调用图片接口服务获取图片流，转base64前端展示
weixin_44378416的博客
04-15 6276
java调用图片接口，获取图片流，前端展示
Java中加载图片并显示
gaoqiandr的博客
02-26 4418
对于如何使用Java中的Image加载图片并使用
Java操作图片大全
热门推荐
7me
11-02 1万+
本文主要使用Java对图片各种操作进行处理。
Java 图片 基础操作
PJZero
12-14 1688
文章目录图片读写读写小总结像素操作属性操作缩放格式转换其他统一缩放每个像素的值执行仿射变换执行卷积获取支持读取的文件格式获取支持写入的文件格式参考 图片读写 读 import javax.imageio.ImageIO; class Test { public static void main(String[] args) throws IOException { // 从文件中...
随笔——Java中常用的图片操作
快乐的小小程序猿
03-19 3270
随笔——Java中常用的图片操作 导入的包 import javax.imageio.ImageIO; import java.awt.*; import java.awt.image.BufferedImage; import java.io.*; 图片的缩放 public static BufferedImage scale(BufferedImage imageToScale, int dWidth, int dHeight) { /* 调整BufferedImage类型的图片为指定的长宽
Java实现图片叠加与拼接操作详解
"本文主要探讨了在Java中如何进行图片的叠加与拼接操作，提供了相关的示例代码，适用于学习和工作中对图像处理有需求的读者。内容包括使用BufferedImage类进行图片处理的基本原理和实践方法，以及读取图片文件为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值