图片处理方法

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.List;

import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;

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

/**
 * 图片操作工具类
 */
public class ImageUtil {

    public ImageUtil() {
        super();
    }

    /**
     * 对图片进行格式转换
     *
     * @param srcPath 读取源图片路径
     * @param toPath 写入图片路径
     * @param readImageFormat 读取图片格式
     * @param writeImageFormat 写入图片格式
     * @throws IOException
     */
    public static void convertFormat(String srcPath, String toPath, String readImageFormat, String writeImageFormat) throws IOException {
        FileInputStream fis = null;
        ImageInputStream iis = null;
        try {
            // 读取图片文件
            fis = new FileInputStream(srcPath);
            Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(readImageFormat);
            ImageReader reader = (ImageReader) it.next();
            // 获取图片流
            iis = ImageIO.createImageInputStream(fis);
            reader.setInput(iis, true);
            ImageReadParam param = reader.getDefaultReadParam();
            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 srcPath 读取源图片路径
     * @param toPath 写入图片路径
     * @param x  剪切起始点x坐标
     * @param y 剪切起始点y坐标
     * @param width 剪切宽度
     * @param height 剪切高度
     * @param readImageFormat 读取图片格式
     * @param writeImageFormat 写入图片格式
     * @throws IOException
     */
    public static 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<ImageReader> 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 static 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 static 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 static 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 static 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 static 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 static 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 static boolean joinImageListHorizontal(String[] pics, String type, String dst_pic) {
        try {
            int len = pics.length;
            if (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();
            }
            if (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 static 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 static boolean joinImageListVertical(String[] pics, String type, String dst_pic) {
        try {
            int len = pics.length;
            if (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_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();
            }
            if (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 static 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 static void mergeImageList(String negativeImagePath, List<String[]> 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);
                    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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static 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 static void drawPoints(String srcImagePath, List<Point> 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 static 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 static 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 static 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 static 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 static 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 {
        // ImageUtil imageObj = new ImageUtil();
        /*
         * 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
        //
        // mergeBothImageCenter("","","")
        // String readFormats[] = ImageIO.getReaderFormatNames();
        // String writeFormats[] = ImageIO.getWriterFormatNames();
        // System.out.println("Readers:" + Arrays.asList(readFormats));
        // System.out.println("Writers:" + Arrays.asList(writeFormats));

        // imageObj.convertFormat("E:/QQ.png","E:/QQ.jpg","png","jpg");

    }
}