級聯分類器

目錄

• 目標
• 理論
• OpenCV 中的 Haar 級聯檢測
• 結果
• 附加資源

上一個教程: 光流
下一個教程: 級聯分類器訓練

原始作者	Ana Huamán
相容性	OpenCV >= 3.0

目標

在本教程中，

• 我們將學習 Haar 級聯物件檢測的工作原理。
• 我們將瞭解使用基於 Haar 特徵的級聯分類器進行人臉檢測和眼睛檢測的基礎知識。
• 我們將使用 cv::CascadeClassifier 類來檢測影片流中的物件。具體來說，我們將使用以下函式：
  • cv::CascadeClassifier::load 載入 .xml 分類器檔案。它可以是 Haar 或 LBP 分類器。
  • cv::CascadeClassifier::detectMultiScale 執行檢測。

理論

基於 Haar 特徵的級聯分類器進行物件檢測是由 Paul Viola 和 Michael Jones 在其 2001 年的論文《使用增強級聯簡單特徵的快速物件檢測》（"Rapid Object Detection using a Boosted Cascade of Simple Features"）中提出的一種有效的物件檢測方法。它是一種基於機器學習的方法，其中級聯函式透過大量正向影像和負向影像進行訓練。然後將其用於檢測其他影像中的物件。

這裡我們將進行人臉檢測。最初，該演算法需要大量正向影像（人臉影像）和負向影像（無人臉影像）來訓練分類器。然後我們需要從中提取特徵。為此，使用瞭如下圖所示的 Haar 特徵。它們就像我們的卷積核。每個特徵是一個透過從黑色矩形下畫素和中減去白色矩形下畫素和而獲得的單個值。

image

現在，每個核的所有可能尺寸和位置都被用來計算大量的特徵。（想象一下這需要多少計算量？即使一個 24x24 的視窗也會產生超過 160000 個特徵）。對於每個特徵計算，我們需要找到白色和黑色矩形下的畫素和。為了解決這個問題，他們引入了積分圖。無論你的影像有多大，它都能將給定畫素的計算簡化為僅涉及四個畫素的操作。很棒，不是嗎？它讓事情變得超快。

但在我們計算的所有這些特徵中，大多數都是不相關的。例如，考慮下圖。頂行顯示了兩個好的特徵。第一個選定的特徵似乎側重於眼睛區域通常比鼻子和臉頰區域更暗的特性。第二個選定的特徵依賴於眼睛比鼻樑更暗的特性。但同樣的視窗應用於臉頰或任何其他地方則是不相關的。那麼我們如何從 160000 多個特徵中選擇最好的特徵呢？這可以透過 Adaboost 實現。

image

為此，我們將每一個特徵應用於所有訓練影像。對於每個特徵，它會找到最佳閾值，將人臉分類為正向和負向。顯然，會存在錯誤或錯誤分類。我們選擇錯誤率最小的特徵，這意味著它們是最能準確分類人臉和非人臉影像的特徵。（這個過程不像這般簡單。開始時，每張影像都被賦予相同的權重。每次分類後，錯誤分類影像的權重會增加。然後重複相同的過程。計算新的錯誤率。同時計算新的權重。這個過程一直持續到達到所需的準確率或錯誤率，或者找到所需的特徵數量）。

最終的分類器是這些弱分類器的加權和。之所以稱之為弱分類器，是因為它單獨無法分類影像，但與其他分類器一起形成一個強分類器。論文指出，即使 200 個特徵也能提供 95% 準確率的檢測。他們的最終設定包含大約 6000 個特徵。（想象一下從 160000 多個特徵減少到 6000 個特徵。這是一個巨大的提升）。

現在你拿一張影像。取每一個 24x24 的視窗。對它應用 6000 個特徵。檢查它是否是人臉。哇……這難道不是有點低效和耗時嗎？是的，確實如此。作者對此有一個很好的解決方案。

在一張影像中，大部分割槽域是非人臉區域。因此，更好的方法是使用一種簡單的方法來檢查一個視窗是否是非人臉區域。如果不是，則立即將其丟棄，不再對其進行處理。相反，專注於可能存在人臉的區域。這樣，我們就可以花更多時間檢查可能的人臉區域。

為此，他們引入了級聯分類器的概念。特徵不是一次性將所有 6000 個特徵應用於一個視窗，而是被分組到不同的分類器階段並逐個應用。（通常前幾個階段會包含極少的特徵）。如果一個視窗在第一階段失敗，就丟棄它。我們不再考慮它上面的剩餘特徵。如果它透過，則應用第二階段的特徵並繼續這個過程。透過所有階段的視窗就是一個人臉區域。這個計劃如何！

作者的檢測器包含 6000 多個特徵，分為 38 個階段，前五個階段分別包含 1、10、25、25 和 50 個特徵。（上圖中所示的兩個特徵實際上是從 Adaboost 中獲得的最佳兩個特徵）。根據作者的說法，平均每個子視窗只評估 6000 多個特徵中的 10 個。

這就是 Viola-Jones 人臉檢測工作原理的簡單直觀解釋。有關更多詳細資訊，請閱讀該論文或查閱“附加資源”部分中的參考文獻。

OpenCV 中的 Haar 級聯檢測

OpenCV 提供了一種訓練方法（參見 級聯分類器訓練）或預訓練模型，可以使用 cv::CascadeClassifier::load 方法讀取。預訓練模型位於 OpenCV 安裝的 data 資料夾中，或可以在 這裡 找到。

以下程式碼示例將使用預訓練的 Haar 級聯模型來檢測影像中的人臉和眼睛。首先，建立一個 cv::CascadeClassifier 並使用 cv::CascadeClassifier::load 方法載入必要的 XML 檔案。之後，使用 cv::CascadeClassifier::detectMultiScale 方法完成檢測，該方法返回檢測到的人臉或眼睛的邊界矩形。

C++

本教程的程式碼如下所示。您也可以從 這裡 下載

#include "opencv2/objdetect.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/videoio.hpp"
#include <iostream>
 
using namespace std;
using namespace cv;
 
void detectAndDisplay( Mat frame );
 
CascadeClassifier face_cascade;
CascadeClassifier eyes_cascade;
 
int main( int argc, const char** argv )
{
    CommandLineParser parser(argc, argv,
                             "{help h||}"
                             "{face_cascade|data/haarcascades/haarcascade_frontalface_alt.xml|Path to face cascade.}"
                             "{eyes_cascade|data/haarcascades/haarcascade_eye_tree_eyeglasses.xml|Path to eyes cascade.}"
                             "{camera|0|Camera device number.}");
 
parser.about( "\nThis program demonstrates using the cv::CascadeClassifier class to detect objects (Face + eyes) in a video stream.\n"
                  "You can use Haar or LBP features.\n\n" );
parser.printMessage();
 
    String face_cascade_name = samples::findFile( parser.get<String>("face_cascade") );
    String eyes_cascade_name = samples::findFile( parser.get<String>("eyes_cascade") );
 
    //-- 1. Load the cascades
    if( !face_cascade.load( face_cascade_name ) )
    {
cout << "--(!)Error loading face cascade\n";
        return -1;
    };
    if( !eyes_cascade.load( eyes_cascade_name ) )
    {
cout << "--(!)Error loading eyes cascade\n";
        return -1;
    };
 
    int camera_device = parser.get<int>("camera");
    VideoCapture capture;
    //-- 2. Read the video stream
capture.open( camera_device );
    if ( ! capture.isOpened() )
    {
cout << "--(!)Error opening video capture\n";
        return -1;
    }
 
    Mat frame;
    while ( capture.read(frame) )
    {
        if( frame.empty() )
        {
cout << "--(!) No captured frame -- Break!\n";
            break;
        }
 
        //-- 3. Apply the classifier to the frame
detectAndDisplay( frame );
 
        if( waitKey(10) == 27 )
        {
            break; // escape
        }
    }
    return 0;
}
 
void detectAndDisplay( Mat frame )
{
    Mat frame_gray;
    cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
    equalizeHist( frame_gray, frame_gray );
 
    //-- Detect faces
std::vector<Rect> faces;
face_cascade.detectMultiScale( frame_gray, faces );
 
    for ( size_t i = 0; i < faces.size(); i++ )
    {
        Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
        ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2 ), 0, 0, 360, Scalar( 255, 0, 255 ), 4 );
 
        Mat faceROI = frame_gray( faces[i] );
 
        //-- In each face, detect eyes
std::vector<Rect> eyes;
eyes_cascade.detectMultiScale( faceROI, eyes );
 
        for ( size_t j = 0; j < eyes.size(); j++ )
        {
            Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
            int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
            circle( frame, eye_center, radius, Scalar( 255, 0, 0 ), 4 );
        }
    }
 
    //-- Show what you got
    imshow( "Capture - Face detection", frame );
}

Java

本教程的程式碼如下所示。您也可以從 這裡 下載

import java.util.List;
 
import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfRect;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.highgui.HighGui;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.videoio.VideoCapture;
 
class ObjectDetection {
    public void detectAndDisplay(Mat frame, CascadeClassifier faceCascade, CascadeClassifier eyesCascade) {
Mat frameGray = new Mat();
Imgproc.cvtColor(frame, frameGray, Imgproc.COLOR_BGR2GRAY);
Imgproc.equalizeHist(frameGray, frameGray);
 
        // -- Detect faces
MatOfRect faces = new MatOfRect();
faceCascade.detectMultiScale(frameGray, faces);
 
List<Rect> listOfFaces = faces.toList();
        for (Rect face : listOfFaces) {
Point center = new Point(face.x + face.width / 2, face.y + face.height / 2);
Imgproc.ellipse(frame, center, new Size(face.width / 2, face.height / 2), 0, 0, 360,
                    new Scalar(255, 0, 255));
 
Mat faceROI = frameGray.submat(face);
 
            // -- In each face, detect eyes
MatOfRect eyes = new MatOfRect();
eyesCascade.detectMultiScale(faceROI, eyes);
 
List<Rect> listOfEyes = eyes.toList();
            for (Rect eye : listOfEyes) {
Point eyeCenter = new Point(face.x + eye.x + eye.width / 2, face.y + eye.y + eye.height / 2);
                int radius = (int) Math.round((eye.width + eye.height) * 0.25);
Imgproc.circle(frame, eyeCenter, radius, new Scalar(255, 0, 0), 4);
            }
        }
 
        //-- Show what you got
HighGui.imshow("Capture - Face detection", frame );
    }
 
    public void run(String[] args) {
String filenameFaceCascade = args.length > 2 ? args[0] : "../../data/haarcascades/haarcascade_frontalface_alt.xml";
String filenameEyesCascade = args.length > 2 ? args[1] : "../../data/haarcascades/haarcascade_eye_tree_eyeglasses.xml";
        int cameraDevice = args.length > 2 ? Integer.parseInt(args[2]) : 0;
 
CascadeClassifier faceCascade = new CascadeClassifier();
CascadeClassifier eyesCascade = new CascadeClassifier();
 
        if (!faceCascade.load(filenameFaceCascade)) {
System.err.println("--(!)Error loading face cascade: " + filenameFaceCascade);
System.exit(0);
        }
        if (!eyesCascade.load(filenameEyesCascade)) {
System.err.println("--(!)Error loading eyes cascade: " + filenameEyesCascade);
System.exit(0);
        }
 
VideoCapture capture = new VideoCapture(cameraDevice);
        if (!capture.isOpened()) {
System.err.println("--(!)Error opening video capture");
System.exit(0);
        }
 
Mat frame = new Mat();
        while (capture.read(frame)) {
            if (frame.empty()) {
System.err.println("--(!) No captured frame -- Break!");
                break;
            }
 
            //-- 3. Apply the classifier to the frame
detectAndDisplay(frame, faceCascade, eyesCascade);
 
            if (HighGui.waitKey(10) == 27) {
                break;// escape
            }
        }
 
System.exit(0);
    }
}
 
public class ObjectDetectionDemo {
    public static void main(String[] args) {
        // 載入本地 OpenCV 庫
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
 
        new ObjectDetection().run(args);
    }
}

Python

本教程的程式碼如下所示。您也可以從 這裡 下載

from __future__ import print_function
import cv2 as cv
import argparse
 
def detectAndDisplay(frame)
frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY)
frame_gray = cv.equalizeHist(frame_gray)
 
    #-- Detect faces
faces = face_cascade.detectMultiScale(frame_gray)
    for (x,y,w,h) in faces
center = (x + w//2, y + h//2)
frame = cv.ellipse(frame, center, (w//2, h//2), 0, 0, 360, (255, 0, 255), 4)
 
faceROI = frame_gray[y:y+h,x:x+w]
        #-- In each face, detect eyes
eyes = eyes_cascade.detectMultiScale(faceROI)
        for (x2,y2,w2,h2) in eyes
eye_center = (x + x2 + w2//2, y + y2 + h2//2)
radius = int(round((w2 + h2)*0.25))
frame = cv.circle(frame, eye_center, radius, (255, 0, 0 ), 4)
 
    cv.imshow('Capture - Face detection', frame)
 
parser = argparse.ArgumentParser(description='Code for Cascade Classifier tutorial.')
parser.add_argument('--face_cascade', help='Path to face cascade.', default='data/haarcascades/haarcascade_frontalface_alt.xml')
parser.add_argument('--eyes_cascade', help='Path to eyes cascade.', default='data/haarcascades/haarcascade_eye_tree_eyeglasses.xml')
parser.add_argument('--camera', help='Camera divide number.', type=int, default=0)
args = parser.parse_args()
 
face_cascade_name = args.face_cascade
eyes_cascade_name = args.eyes_cascade
 
face_cascade = cv.CascadeClassifier()
eyes_cascade = cv.CascadeClassifier()
 
#-- 1. Load the cascades
if not face_cascade.load(cv.samples.findFile(face_cascade_name))
print('--(!)Error loading face cascade')
exit(0)
if not eyes_cascade.load(cv.samples.findFile(eyes_cascade_name))
print('--(!)Error loading eyes cascade')
exit(0)
 
camera_device = args.camera
#-- 2. Read the video stream
cap = cv.VideoCapture(camera_device)
if not cap.isOpened
print('--(!)Error opening video capture')
exit(0)
 
while True
ret, frame = cap.read()
    if frame is None
print('--(!) No captured frame -- Break!')
        break
 
detectAndDisplay(frame)
 
    if cv.waitKey(10) == 27
        break

結果

1. 這是執行上述程式碼並使用內建網路攝像頭影片流作為輸入的結果

請確保程式能夠找到檔案 haarcascade_frontalface_alt.xml 和 haarcascade_eye_tree_eyeglasses.xml 的路徑。它們位於 opencv/data/haarcascades 中。

1. 這是使用檔案 lbpcascade_frontalface.xml (LBP 訓練) 進行人臉檢測的結果。對於眼睛，我們仍沿用教程中使用的檔案。

附加資源

1. Paul Viola 和 Michael J. Jones. 魯棒的即時人臉檢測. International Journal of Computer Vision, 57(2):137–154, 2004. [289]
2. Rainer Lienhart 和 Jochen Maydt. 用於快速物件檢測的擴充套件 Haar-like 特徵集. In Image Processing. 2002. Proceedings. 2002 International Conference on, volume 1, pages I–900. IEEE, 2002. [170]
3. 關於 人臉檢測與跟蹤 的影片講座
4. Adam Harvey 關於人臉檢測的一次有趣的採訪 Adam Harvey
5. OpenCV 人臉檢測：視覺化 在 Vimeo 上由 Adam Harvey 提供