基於 OpenCV 的影象匹配（ Java 版）

預流發表於2018-01-24
OpenCVJava

最近在做影象匹配的事，發現原來有個叫 OpenCV 的庫，非常強大，跨平臺、多語言介面、在計算機視覺和影象處理上提供了多個通用演算法，應用的領域包括了物體識別、人臉識別、影象分割、機器視覺、運動分析。因為涉及了一些影象處理的概念和演算法，對於常年做業務系統的程式設計師來說很少碰這領域，所以分享一下問題的處理過程。

OpenCV 的安裝

先看下這個庫的安裝，它是跨平臺的，主流的作業系統都支援，以作業系統 OS X 、開發工具 IntelliJ IDEA 為例，看下這個庫的安裝和配置過程。

OpenCV 最新的版本是3.2.0，所以看這個版本的安裝說明，頁面上有Linux、Windows、Android、iOS等不同平臺的安裝介紹，由於我用的是Java，所以直接看 Introduction to Java Development 安裝過程共分下面幾步：

  1. git 下載原始碼 選擇一個目錄，用 git 下載 OpenCV 的原始碼
git clone git://github.com/opencv/opencv.git
複製程式碼
  1. 切換 git 程式碼分支 進入 opencv 的目錄下，切換分支
cd opencv
git checkout 2.4
複製程式碼
  1. 新建 build 目錄 在 opencv 目錄下新建 build 目錄用於存放編譯後的檔案
mkdir build
cd build
複製程式碼
  1. 編譯整個專案程式碼
cmake -DBUILD_SHARED_LIBS=OFF ..
複製程式碼

當控制檯輸出裡有"To be built"這行，裡面包含了"java"，則表示專案編譯成功了。

編譯成功
5. build 整個專案

make -j8
複製程式碼

執行完 make 命令後看下 build 目錄下的 bin 目錄內容，如果有檔案叫 opencv-2413.jar，則說明 opencv 已經編譯安裝好了。

bin 目錄內容

以上步驟執行完，實際就具備了 java 介面訪問 openCV 的能力了。而要在 IntelliJ IDEA 中訪問 OpenCV ，還需要兩部配置：

  1. 給專案新增 jar 包 在專案的 Libraries 中新增上面 build 之後的 bin 目錄下的 opencv-2413.jar

    點選+號，選擇 Java
    之後選擇 opencv-2413.jar 所在位置。
    選擇 jar 檔案

  2. 寫一個測試 OpenCV 環境的類

package org.study.image.openCV;

import org.opencv.core.Core;

public class OpenCVTest {
    public static void main(String[] args) {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
    }
}
複製程式碼

這個類裡面就一句話，載入本地的openCV庫。

  1. 配置 Java Application 的執行引數

此時執行這個類會報 UnsatisfiedLinkError 的錯誤，提示【no opencv_java2413 in java.library.path】：

連結錯誤
所以需要配置 Java Application 的執行時引數，在 java.library.path 加上上面 OpenCV 編譯之後的 build 目錄下的 lib 目錄：
配置執行時引數
這樣就可以在 Java 環境中訪問 OpenCV 庫了。

問題描述

要解決的問題是判斷一張圖片是否在另一張圖片之中，比如下面這兩張圖：

大圖
小圖

肉眼上能看出來下面的圖片其實就是在上面圖片的左下區域，可是用計算機如何給出這種判斷來代替人工呢？

基於畫素的模板匹配

最開始搜到的資料就是 OpenCV 裡的模板匹配，其原理是通過一張模板圖片去另一張圖中找到與模板相似部分（以上面的例子來說模板就是上面的小圖）。模板匹配演算法是指通過滑窗的方式在待匹配的影象上滑動，通過比較模板與子圖的相似度，找到相似度最大的子圖。

所謂滑窗就是通過滑動圖片，使得影象塊一次移動一個畫素（從左到右，從上往下）。在每一個位置，都進行一次度量計算來這個影象塊和原影象的特定區域的畫素值相似程度。當相似度足夠高時，就認為找到了目標。顯然，這裡“相似程度”的定義依賴於具體的計算公式給出的結果，不同演算法結果也不一樣。

目前 OpenCV 裡提供了六種演算法：TM_SQDIFF（平方差匹配法）、TM_SQDIFF_NORMED（歸一化平方差匹配法）、TM_CCORR（相關匹配法）、TM_CCORR_NORMED（歸一化相關匹配法）、TM_CCOEFF（相關係數匹配法）、TM_CCOEFF_NORMED（歸一化相關係數匹配法）。

下面是 Java 中使用 OpenCV 的模板匹配的程式碼：

package org.study.image.openCV;

import org.opencv.core.*;
import org.opencv.highgui.Highgui;
import org.opencv.imgproc.Imgproc;

public class OpenCVTest {
    public static void main(String[] args) {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
        Mat source, template;
        //將檔案讀入為OpenCV的Mat格式
        source = Highgui.imread("/Users/niwei/Downloads/原圖.jpeg");
        template = Highgui.imread("/Users/niwei/Downloads/模板.jpeg");
        //建立於原圖相同的大小，儲存匹配度
        Mat result = Mat.zeros(source.rows() - template.rows() + 1, source.cols() - template.cols() + 1, CvType.CV_32FC1);
        //呼叫模板匹配方法
        Imgproc.matchTemplate(source, template, result, Imgproc.TM_SQDIFF_NORMED);
        //規格化
        Core.normalize(result, result, 0, 1, Core.NORM_MINMAX, -1);
        //獲得最可能點，MinMaxLocResult是其資料格式，包括了最大、最小點的位置x、y
        Core.MinMaxLocResult mlr = Core.minMaxLoc(result);
        Point matchLoc = mlr.minLoc;
        //在原圖上的對應模板可能位置畫一個綠色矩形
        Core.rectangle(source, matchLoc, new Point(matchLoc.x + template.width(), matchLoc.y + template.height()), new Scalar(0, 255, 0));
        //將結果輸出到對應位置
        Highgui.imwrite("/Users/niwei/Downloads/匹配結果.jpeg", source);
    }
}
複製程式碼

原圖
模板
匹配後的結果圖片:
匹配結果圖
可以看到匹配結果圖中已經用綠色矩形將該區域標識出來了，其實匹配結果能這麼好是主要因為上面的模板圖和原圖實際上是從一張圖片裡面用同樣的精度擷取出來的，如果是這種情況用模板匹配演算法是可行的。

但它的缺陷在於如果模板圖片發生了旋轉、縮放之後，這種通過滑窗的模板匹配方式就會失效，那又如何處理呢？

基於特徵點的 SURF 匹配

要解決旋轉縮放後的模板圖片再匹配原圖的問題，就用到了計算機視覺處理演算法中的特徵變換匹配演算法。其思路是先找到影象中的一些“穩定點”，這些點不會因為視角的改變、光照的變化、噪音的干擾而消失，比如角點、邊緣點、暗區域的亮點以及亮區域的暗點。這樣如果兩幅圖中有相同的景物，那麼穩定點就會在兩幅影象的相同景物上同時出現，這樣就能實現匹配。

OpenCV 中針對特徵點匹配問題已經提供了很多演算法，包括 FAST 、SIFT 、SURF 、ORB 等，這裡不贅述這些演算法之間的區別，直接以 SURF 為例，看下 OpenCV 裡面如何應用的。

package com.zhiqu.image.recognition;

import org.opencv.calib3d.Calib3d;
import org.opencv.core.*;
import org.opencv.features2d.*;
import org.opencv.highgui.Highgui;

import java.util.LinkedList;
import java.util.List;

/**
 * Created by niwei on 2017/4/28.
 */
public class ImageRecognition {

    private float nndrRatio = 0.7f;//這裡設定既定值為0.7，該值可自行調整

    private int matchesPointCount = 0;

    public float getNndrRatio() {
        return nndrRatio;
    }

    public void setNndrRatio(float nndrRatio) {
        this.nndrRatio = nndrRatio;
    }

    public int getMatchesPointCount() {
        return matchesPointCount;
    }

    public void setMatchesPointCount(int matchesPointCount) {
        this.matchesPointCount = matchesPointCount;
    }

    public void matchImage(Mat templateImage, Mat originalImage) {
        MatOfKeyPoint templateKeyPoints = new MatOfKeyPoint();
        //指定特徵點演算法SURF
        FeatureDetector featureDetector = FeatureDetector.create(FeatureDetector.SURF);
        //獲取模板圖的特徵點
        featureDetector.detect(templateImage, templateKeyPoints);
        //提取模板圖的特徵點
        MatOfKeyPoint templateDescriptors = new MatOfKeyPoint();
        DescriptorExtractor descriptorExtractor = DescriptorExtractor.create(DescriptorExtractor.SURF);
        System.out.println("提取模板圖的特徵點");
        descriptorExtractor.compute(templateImage, templateKeyPoints, templateDescriptors);

        //顯示模板圖的特徵點圖片
        Mat outputImage = new Mat(templateImage.rows(), templateImage.cols(), Highgui.CV_LOAD_IMAGE_COLOR);
        System.out.println("在圖片上顯示提取的特徵點");
        Features2d.drawKeypoints(templateImage, templateKeyPoints, outputImage, new Scalar(255, 0, 0), 0);

        //獲取原圖的特徵點
        MatOfKeyPoint originalKeyPoints = new MatOfKeyPoint();
        MatOfKeyPoint originalDescriptors = new MatOfKeyPoint();
        featureDetector.detect(originalImage, originalKeyPoints);
        System.out.println("提取原圖的特徵點");
        descriptorExtractor.compute(originalImage, originalKeyPoints, originalDescriptors);

        List<MatOfDMatch> matches = new LinkedList();
        DescriptorMatcher descriptorMatcher = DescriptorMatcher.create(DescriptorMatcher.FLANNBASED);
        System.out.println("尋找最佳匹配");
        /**
         * knnMatch方法的作用就是在給定特徵描述集合中尋找最佳匹配
         * 使用KNN-matching演算法，令K=2，則每個match得到兩個最接近的descriptor，然後計算最接近距離和次接近距離之間的比值，當比值大於既定值時，才作為最終match。
         */
        descriptorMatcher.knnMatch(templateDescriptors, originalDescriptors, matches, 2);

        System.out.println("計算匹配結果");
        LinkedList<DMatch> goodMatchesList = new LinkedList();

        //對匹配結果進行篩選，依據distance進行篩選
        matches.forEach(match -> {
            DMatch[] dmatcharray = match.toArray();
            DMatch m1 = dmatcharray[0];
            DMatch m2 = dmatcharray[1];

            if (m1.distance <= m2.distance * nndrRatio) {
                goodMatchesList.addLast(m1);
            }
        });

        matchesPointCount = goodMatchesList.size();
        //當匹配後的特徵點大於等於 4 個，則認為模板圖在原圖中，該值可以自行調整
        if (matchesPointCount >= 4) {
            System.out.println("模板圖在原圖匹配成功！");

            List<KeyPoint> templateKeyPointList = templateKeyPoints.toList();
            List<KeyPoint> originalKeyPointList = originalKeyPoints.toList();
            LinkedList<Point> objectPoints = new LinkedList();
            LinkedList<Point> scenePoints = new LinkedList();
            goodMatchesList.forEach(goodMatch -> {
                objectPoints.addLast(templateKeyPointList.get(goodMatch.queryIdx).pt);
                scenePoints.addLast(originalKeyPointList.get(goodMatch.trainIdx).pt);
            });
            MatOfPoint2f objMatOfPoint2f = new MatOfPoint2f();
            objMatOfPoint2f.fromList(objectPoints);
            MatOfPoint2f scnMatOfPoint2f = new MatOfPoint2f();
            scnMatOfPoint2f.fromList(scenePoints);
            //使用 findHomography 尋找匹配上的關鍵點的變換
            Mat homography = Calib3d.findHomography(objMatOfPoint2f, scnMatOfPoint2f, Calib3d.RANSAC, 3);

            /**
             * 透視變換(Perspective Transformation)是將圖片投影到一個新的視平面(Viewing Plane)，也稱作投影對映(Projective Mapping)。
             */
            Mat templateCorners = new Mat(4, 1, CvType.CV_32FC2);
            Mat templateTransformResult = new Mat(4, 1, CvType.CV_32FC2);
            templateCorners.put(0, 0, new double[]{0, 0});
            templateCorners.put(1, 0, new double[]{templateImage.cols(), 0});
            templateCorners.put(2, 0, new double[]{templateImage.cols(), templateImage.rows()});
            templateCorners.put(3, 0, new double[]{0, templateImage.rows()});
            //使用 perspectiveTransform 將模板圖進行透視變以矯正圖象得到標準圖片
            Core.perspectiveTransform(templateCorners, templateTransformResult, homography);

            //矩形四個頂點
            double[] pointA = templateTransformResult.get(0, 0);
            double[] pointB = templateTransformResult.get(1, 0);
            double[] pointC = templateTransformResult.get(2, 0);
            double[] pointD = templateTransformResult.get(3, 0);

            //指定取得陣列子集的範圍
            int rowStart = (int) pointA[1];
            int rowEnd = (int) pointC[1];
            int colStart = (int) pointD[0];
            int colEnd = (int) pointB[0];
            Mat subMat = originalImage.submat(rowStart, rowEnd, colStart, colEnd);
            Highgui.imwrite("/Users/niwei/Desktop/opencv/原圖中的匹配圖.jpg", subMat);

            //將匹配的影象用用四條線框出來
            Core.line(originalImage, new Point(pointA), new Point(pointB), new Scalar(0, 255, 0), 4);//上 A->B
            Core.line(originalImage, new Point(pointB), new Point(pointC), new Scalar(0, 255, 0), 4);//右 B->C
            Core.line(originalImage, new Point(pointC), new Point(pointD), new Scalar(0, 255, 0), 4);//下 C->D
            Core.line(originalImage, new Point(pointD), new Point(pointA), new Scalar(0, 255, 0), 4);//左 D->A

            MatOfDMatch goodMatches = new MatOfDMatch();
            goodMatches.fromList(goodMatchesList);
            Mat matchOutput = new Mat(originalImage.rows() * 2, originalImage.cols() * 2, Highgui.CV_LOAD_IMAGE_COLOR);
            Features2d.drawMatches(templateImage, templateKeyPoints, originalImage, originalKeyPoints, goodMatches, matchOutput, new Scalar(0, 255, 0), new Scalar(255, 0, 0), new MatOfByte(), 2);

            Highgui.imwrite("/Users/niwei/Desktop/opencv/特徵點匹配過程.jpg", matchOutput);
            Highgui.imwrite("/Users/niwei/Desktop/opencv/模板圖在原圖中的位置.jpg", originalImage);
        } else {
            System.out.println("模板圖不在原圖中！");
        }

        Highgui.imwrite("/Users/niwei/Desktop/opencv/模板特徵點.jpg", outputImage);
    }

    public static void main(String[] args) {
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

        String templateFilePath = "/Users/niwei/Desktop/opencv/模板.jpeg";
        String originalFilePath = "/Users/niwei/Desktop/opencv/原圖.jpeg";
        //讀取圖片檔案
        Mat templateImage = Highgui.imread(templateFilePath, Highgui.CV_LOAD_IMAGE_COLOR);
        Mat originalImage = Highgui.imread(originalFilePath, Highgui.CV_LOAD_IMAGE_COLOR);

        ImageRecognition imageRecognition = new ImageRecognition();
        imageRecognition.matchImage(templateImage, originalImage);

        System.out.println("匹配的畫素點總數：" + imageRecognition.getMatchesPointCount());
    }
}
複製程式碼

程式碼解釋見文中的註釋，執行結果如下：

原圖
模板
模板特徵點
特徵點匹配過程
匹配結果

相關文章