Java實現圖片的疊加與拼接

時間 2019-12-04

標籤 java 實現圖片疊加拼接欄目 Java 简体版

原文原文鏈接

關於Java實現圖片的疊加與拼接的文章網絡上確實不少，碰巧小編開發工做中也遇到這些問題，就作了簡要的梳理，做爲筆記以備不時之需。html

Java對圖片的處理主要使用的是BufferedImage類。java

BufferedImage 子類描述具備可訪問圖像數據緩衝區的 Image。BufferedImage 由圖像數據的 ColorModel 和 Raster 組成。Raster 的 SampleModel 中 band 的數量和類型必須與 ColorModel 所要求的數量和類型相匹配，以表示其顏色和 alpha 份量。全部 BufferedImage 對象的左上角座標都爲 (0, 0)。所以，用來構造 BufferedImage 的任何 Raster 都必須知足：minX=0 且 minY=0。此類依靠 Raster 的數據獲取方法、數據設置方法，以及 ColorModel 的顏色特徵化方法。 api

以上主要來源於官方文檔，咱們來時直接寫實踐代碼吧。數組

首先將文件轉化爲BufferedImage對象，這裏給出兩種讀取文件並轉化爲BufferedImage對象的方法。緩存

    /**
     * @param fileUrl 文件絕對路徑或相對路徑
     * @return 讀取到的緩存圖像
     * @throws IOException 路徑錯誤或者不存在該文件時拋出IO異常
     */
    public static BufferedImage getBufferedImage(String fileUrl)
            throws IOException {
        File f = new File(fileUrl);
        return ImageIO.read(f);
    }    
    
    /**
     * 遠程圖片轉BufferedImage
     * @param destUrl    遠程圖片地址
     * @return
     */
    public static BufferedImage getBufferedImageDestUrl(String destUrl) {
        HttpURLConnection conn = null;
        BufferedImage image = null;
        try {
            URL url = new URL(destUrl);
            conn = (HttpURLConnection) url.openConnection();
            if (conn.getResponseCode() == 200) {
                image = ImageIO.read(conn.getInputStream());
                return image;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            conn.disconnect();
        }
        return image;
    }

接下來是將BufferedImage對象保存到本地，具體方法以下:網絡

    /**
     * 輸出圖片
     * @param buffImg  圖像拼接疊加以後的BufferedImage對象
     * @param savePath 圖像拼接疊加以後的保存路徑
     */
    public static void generateSaveFile(BufferedImage buffImg, String savePath) {
        int temp = savePath.lastIndexOf(".") + 1;
        try {
            File outFile = new File(savePath);
            if(!outFile.exists()){
                outFile.createNewFile();
            }
            ImageIO.write(buffImg, savePath.substring(temp), outFile);
            System.out.println("ImageIO write...");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

以上做爲準備部分，如今開始圖片疊加的實現方法：ide

　　/**
     * 
     * @Title: 構造圖片
     * @Description: 生成水印並返回java.awt.image.BufferedImage
     * @param buffImg 源文件(BufferedImage)
     * @param waterFile 水印文件(BufferedImage)
     * @param x 距離右下角的X偏移量
     * @param y  距離右下角的Y偏移量
     * @param alpha  透明度, 選擇值從0.0~1.0: 徹底透明~徹底不透明
     * @return BufferedImage
     * @throws IOException
     */
    public static BufferedImage overlyingImage(BufferedImage buffImg, BufferedImage waterImg, int x, int y, float alpha) throws IOException {

        // 建立Graphics2D對象，用在底圖對象上繪圖
        Graphics2D g2d = buffImg.createGraphics();
        int waterImgWidth = waterImg.getWidth();// 獲取層圖的寬度
        int waterImgHeight = waterImg.getHeight();// 獲取層圖的高度
        // 在圖形和圖像中實現混合和透明效果
        g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
        // 繪製
        g2d.drawImage(waterImg, x, y, waterImgWidth, waterImgHeight, null);
        g2d.dispose();// 釋放圖形上下文使用的系統資源
        return buffImg;
    }

圖片拼接的實現方法：測試

    /**
     * 待合併的兩張圖必須知足這樣的前提，若是水平方向合併，則高度必須相等；若是是垂直方向合併，寬度必須相等。
     * mergeImage方法不作判斷，本身判斷。 
     * @param img1 待合併的第一張圖
     * @param img2 帶合併的第二張圖
     * @param isHorizontal 爲true時表示水平方向合併，爲false時表示垂直方向合併
     * @return 返回合併後的BufferedImage對象
     * @throws IOException
     */
    public static BufferedImage mergeImage(BufferedImage img1,
            BufferedImage img2, boolean isHorizontal) throws IOException {
        int w1 = img1.getWidth();
        int h1 = img1.getHeight();
        int w2 = img2.getWidth();
        int h2 = img2.getHeight();

        // 從圖片中讀取RGB
        int[] ImageArrayOne = new int[w1 * h1];
        ImageArrayOne = img1.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 逐行掃描圖像中各個像素的RGB到數組中
        int[] ImageArrayTwo = new int[w2 * h2];
        ImageArrayTwo = img2.getRGB(0, 0, w2, h2, ImageArrayTwo, 0, w2);

        // 生成新圖片
        BufferedImage DestImage = null;
        if (isHorizontal) { // 水平方向合併
            DestImage = new BufferedImage(w1+w2, h1, BufferedImage.TYPE_INT_RGB);
            DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 設置上半部分或左半部分的RGB
            DestImage.setRGB(w1, 0, w2, h2, ImageArrayTwo, 0, w2);
        } else { // 垂直方向合併
            DestImage = new BufferedImage(w1, h1 + h2, BufferedImage.TYPE_INT_RGB);
            DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 設置上半部分或左半部分的RGB
            DestImage.setRGB(0, h1, w2, h2, ImageArrayTwo, 0, w2); // 設置下半部分的RGB
        }

        return DestImage;
    }

測試方法以下：url

/**
     * Java 測試圖片疊加方法
     */
    public static void overlyingImageTest() {

        String sourceFilePath = "D://test//test1.jpg";
        String waterFilePath = "D://test//test2.jpg";
        String saveFilePath = "D://test//overlyingImageNew.jpg";
        try {
            BufferedImage bufferImage1 = getBufferedImage(sourceFilePath);
            BufferedImage bufferImage2 = getBufferedImage(waterFilePath);

            // 構建疊加層
            BufferedImage buffImg = overlyingImage(bufferImage1, bufferImage2, 0, 0, 1.0f);
            // 輸出水印圖片
            generateSaveFile(buffImg, saveFilePath);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    
    
    /**
     * Java 測試圖片合併方法
     */
    public static void imageMargeTest() {
        // 讀取待合併的文件
        BufferedImage bi1 = null;
        BufferedImage bi2 = null;
        // 調用mergeImage方法得到合併後的圖像
        BufferedImage destImg = null;
        System.out.println("下面是垂直合併的狀況：");
        String saveFilePath = "D://test//new1.jpg";
        String divingPath = "D://test//new2.jpg";
        String margeImagePath = "D://test//margeNew.jpg";
        try {
            bi1 = getBufferedImage(saveFilePath);
            bi2 = getBufferedImage(divingPath);
            // 調用mergeImage方法得到合併後的圖像
            destImg = mergeImage(bi1, bi2, false);
        } catch (IOException e) {
            e.printStackTrace();
        }
        // 保存圖像
        generateSaveFile(destImg, margeImagePath);
        System.out.println("垂直合併完畢!");
    }

    public static void main(String[] args) {
        // 測試圖片的疊加
        overlyingImageTest();
        // 測試圖片的垂直合併
        imageMargeTest();
    }

View Code

總體代碼以下：spa

  1 package ImagePackage;
  2 
  3 import java.awt.AlphaComposite;
  4 import java.awt.Graphics2D;
  5 import java.awt.image.BufferedImage;
  6 import java.io.File;
  7 import java.io.IOException;
  8 import java.net.HttpURLConnection;
  9 import java.net.URL;
 10 
 11 import javax.imageio.ImageIO;
 12 
 13 /**
 14 
 15  * 該類實現了圖片的合併功能，能夠選擇水平合併或者垂直合併。
 16  * 固然此例只是針對兩個圖片的合併，若是想要實現多個圖片的合併，只須要本身實現方法 BufferedImage
 17  * mergeImage(BufferedImage[] imgs, boolean isHorizontal)便可；
 18  * 並且這個方法更加具備通用性，可是時間緣由不實現了，方法和兩張圖片實現是同樣的
 19  */
 20 
 21 public class ImageMerge {
 22 
 23     /**
 24      * @param fileUrl
 25      *            文件絕對路徑或相對路徑
 26      * @return 讀取到的緩存圖像
 27      * @throws IOException
 28      *             路徑錯誤或者不存在該文件時拋出IO異常
 29      */
 30     public static BufferedImage getBufferedImage(String fileUrl)
 31             throws IOException {
 32         File f = new File(fileUrl);
 33         return ImageIO.read(f);
 34     }
 35     
 36     
 37     /**
 38      * 遠程圖片轉BufferedImage
 39      * @param destUrl    遠程圖片地址
 40      * @return
 41      */
 42     public static BufferedImage getBufferedImageDestUrl(String destUrl) {
 43         HttpURLConnection conn = null;
 44         BufferedImage image = null;
 45         try {
 46             URL url = new URL(destUrl);
 47             conn = (HttpURLConnection) url.openConnection();
 48             if (conn.getResponseCode() == 200) {
 49                 image = ImageIO.read(conn.getInputStream());
 50                 return image;
 51             }
 52         } catch (Exception e) {
 53             e.printStackTrace();
 54         } finally {
 55             conn.disconnect();
 56         }
 57         return image;
 58     }
 59     
 60     /**
 61      * 輸出圖片
 62      * 
 63      * @param buffImg
 64      *            圖像拼接疊加以後的BufferedImage對象
 65      * @param savePath
 66      *            圖像拼接疊加以後的保存路徑
 67      */
 68     public static void generateSaveFile(BufferedImage buffImg, String savePath) {
 69         int temp = savePath.lastIndexOf(".") + 1;
 70         try {
 71             File outFile = new File(savePath);
 72             if(!outFile.exists()){
 73                 outFile.createNewFile();
 74             }
 75             ImageIO.write(buffImg, savePath.substring(temp), outFile);
 76             System.out.println("ImageIO write...");
 77         } catch (IOException e) {
 78             e.printStackTrace();
 79         }
 80     }
 81     
 82     /**
 83      * 
 84      * @Title: 構造圖片
 85      * @Description: 生成水印並返回java.awt.image.BufferedImage
 86      * @param buffImg
 87      *            源文件(BufferedImage)
 88      * @param waterFile
 89      *            水印文件(BufferedImage)
 90      * @param x
 91      *            距離右下角的X偏移量
 92      * @param y
 93      *            距離右下角的Y偏移量
 94      * @param alpha
 95      *            透明度, 選擇值從0.0~1.0: 徹底透明~徹底不透明
 96      * @return BufferedImage
 97      * @throws IOException
 98      */
 99     public static BufferedImage overlyingImage(BufferedImage buffImg, BufferedImage waterImg, int x, int y, float alpha) throws IOException {
100 
101         // 建立Graphics2D對象，用在底圖對象上繪圖
102         Graphics2D g2d = buffImg.createGraphics();
103         int waterImgWidth = waterImg.getWidth();// 獲取層圖的寬度
104         int waterImgHeight = waterImg.getHeight();// 獲取層圖的高度
105         // 在圖形和圖像中實現混合和透明效果
106         g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_ATOP, alpha));
107         // 繪製
108         g2d.drawImage(waterImg, x, y, waterImgWidth, waterImgHeight, null);
109         g2d.dispose();// 釋放圖形上下文使用的系統資源
110         return buffImg;
111     }
112     
113     
114     /**
115      * 待合併的兩張圖必須知足這樣的前提，若是水平方向合併，則高度必須相等；若是是垂直方向合併，寬度必須相等。
116      * mergeImage方法不作判斷，本身判斷。
117      *
118      * @param img1
119      *            待合併的第一張圖
120      * @param img2
121      *            帶合併的第二張圖
122      * @param isHorizontal
123      *            爲true時表示水平方向合併，爲false時表示垂直方向合併
124      * @return 返回合併後的BufferedImage對象
125      * @throws IOException
126      */
127     public static BufferedImage mergeImage(BufferedImage img1,
128             BufferedImage img2, boolean isHorizontal) throws IOException {
129         int w1 = img1.getWidth();
130         int h1 = img1.getHeight();
131         int w2 = img2.getWidth();
132         int h2 = img2.getHeight();
133 
134         // 從圖片中讀取RGB
135         int[] ImageArrayOne = new int[w1 * h1];
136         ImageArrayOne = img1.getRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 逐行掃描圖像中各個像素的RGB到數組中
137         int[] ImageArrayTwo = new int[w2 * h2];
138         ImageArrayTwo = img2.getRGB(0, 0, w2, h2, ImageArrayTwo, 0, w2);
139 
140         // 生成新圖片
141         BufferedImage DestImage = null;
142         if (isHorizontal) { // 水平方向合併
143             DestImage = new BufferedImage(w1+w2, h1, BufferedImage.TYPE_INT_RGB);
144             DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 設置上半部分或左半部分的RGB
145             DestImage.setRGB(w1, 0, w2, h2, ImageArrayTwo, 0, w2);
146         } else { // 垂直方向合併
147             DestImage = new BufferedImage(w1, h1 + h2, BufferedImage.TYPE_INT_RGB);
148             DestImage.setRGB(0, 0, w1, h1, ImageArrayOne, 0, w1); // 設置上半部分或左半部分的RGB
149             DestImage.setRGB(0, h1, w2, h2, ImageArrayTwo, 0, w2); // 設置下半部分的RGB
150         }
151 
152         return DestImage;
153     }
154 
155     /**
156      * Java 測試圖片疊加方法
157      */
158     public static void overlyingImageTest() {
159 
160         String sourceFilePath = "D://test//test1.jpg";
161         String waterFilePath = "D://test//test2.jpg";
162         String saveFilePath = "D://test//overlyingImageNew.jpg";
163         try {
164             BufferedImage bufferImage1 = getBufferedImage(sourceFilePath);
165             BufferedImage bufferImage2 = getBufferedImage(waterFilePath);
166 
167             // 構建疊加層
168             BufferedImage buffImg = overlyingImage(bufferImage1, bufferImage2, 0, 0, 1.0f);
169             // 輸出水印圖片
170             generateSaveFile(buffImg, saveFilePath);
171         } catch (IOException e) {
172             e.printStackTrace();
173         }
174 
175     }
176     
177     
178     /**
179      * Java 測試圖片合併方法
180      */
181     public static void imageMargeTest() {
182         // 讀取待合併的文件
183         BufferedImage bi1 = null;
184         BufferedImage bi2 = null;
185         // 調用mergeImage方法得到合併後的圖像
186         BufferedImage destImg = null;
187         System.out.println("下面是垂直合併的狀況：");
188         String saveFilePath = "D://test//new1.jpg";
189         String divingPath = "D://test//new2.jpg";
190         String margeImagePath = "D://test//margeNew.jpg";
191         try {
192             bi1 = getBufferedImage(saveFilePath);
193             bi2 = getBufferedImage(divingPath);
194             // 調用mergeImage方法得到合併後的圖像
195             destImg = mergeImage(bi1, bi2, false);
196         } catch (IOException e) {
197             e.printStackTrace();
198         }
199         // 保存圖像
200         generateSaveFile(destImg, margeImagePath);
201         System.out.println("垂直合併完畢!");
202     }
203 
204     public static void main(String[] args) {
205         // 測試圖片的疊加
206         overlyingImageTest();
207         // 測試圖片的垂直合併
208         imageMargeTest();
209     }
210 
211 }