OpenCV 级联分类器实战:基于 Haar 特征与 LBP 特征的人脸、人眼实时检测(xobjdetect 模块)

原创2026-09-23 11:43:021,936 阅读
文章标签:计算机视觉图像处理人工智能3D渲染深度学习音视频CANNAscend科学计算OCR

OpenCV 级联分类器实战:基于 Haar 特征与 LBP 特征的人脸、人眼实时检测(xobjdetect 模块)

本文以 opencv_contrib 仓库 xobjdetect 模块的 Cascade Classifier 教程 为主体,系统讲解 Paul Viola 与 Michael Jones 提出的 Haar 特征级联分类器目标检测原理,并结合仓库内的 CascadeClassifier 类源码 与完整的 C++/Python/Java 示例,带你从理论到实践,在视频流中完成人脸与人眼的实时检测。读完本文,你将掌握 cv::CascadeClassifier 的模型加载、detectMultiScale 参数调优,以及如何用仓库自带的预训练 Haar / LBP 级联模型快速落地一个可运行的检测程序。

本教程的目标

本教程的完整代码与说明位于 modules/xobjdetect/tutorials/cascade_classifier/,通过学习你将掌握:

  • Haar 级联目标检测(Haar cascade object detection)的基本工作原理;
  • 使用 Haar 特征级联分类器(Haar Feature-based Cascade Classifiers)做人脸检测与人眼检测的基础方法;
  • 使用 cv::CascadeClassifier 类在视频流中检测对象,具体会用到两个核心函数:

理论基础:Viola-Jones 级联分类器

基于 Haar 特征的级联分类器目标检测,是一种高效的目标检测方法,由 Paul Viola 和 Michael Jones 在 2001 年的论文 "Rapid Object Detection using a Boosted Cascade of Simple Features" 中提出。这是一种基于机器学习的方法:先从大量正样本(positive images,即包含目标的图像)和负样本(negative images,即不包含目标的图像)中训练出一个级联函数,再将其用于其他图像中的目标检测。

以下以人脸检测为例展开原理。

Haar 特征与积分图

训练之初,算法需要大量正样本(人脸图像)和负样本(不含人脸的图像)来训练分类器,然后从中提取特征。这里使用的就是 Haar 特征,如下图所示,它们与我们熟悉的卷积核非常相似。

Haar 特征示意:边缘特征、线特征与四矩形特征

每个 Haar 特征是一个单一数值,计算方式为:白色矩形覆盖区域的像素和 减去 黑色矩形覆盖区域的像素和。

在检测时,每个特征核的所有可能尺寸与位置都会被用来计算大量特征(可以想象一下这个计算量——仅仅一个 24x24 的窗口就会产生超过 160000 个特征)。而计算每个特征都需要求白色与黑色矩形区域内的像素和。为解决这一开销,论文引入了积分图(integral image):无论图像多大,任意矩形区域的像素和都可以化简为只涉及四个像素的操作,这使特征计算变得极快。

Adaboost:从海量特征中挑选最优特征

在上述计算出的海量特征中,大部分是无关紧要的。例如下图:

特征选择示意:好的特征聚焦于眼睛区域与鼻梁、脸颊的灰度差异

图中第一行展示了两个"好"特征:第一个特征聚焦于"眼睛区域通常比鼻子和脸颊区域更暗"这一性质;第二个特征依赖于"眼睛比鼻梁更暗"。而同样的窗口应用到脸颊或其他位置则毫无意义。那么,如何从 16 万多个特征中选出最好的特征呢?答案是 Adaboost(自适应增强)。

其过程是:将每个特征逐一应用到所有训练图像上,为每个特征找到能把人脸分类为正、负的最佳阈值;显然会产生错误或误分类。于是选择错误率最低的特征,即最能准确区分人脸与非人脸图像的特征。(实际过程并非如此简单:最初每张图像被赋予相等的权重;每轮分类后,被误分类图像的权重会增大,然后重复相同过程,重新计算错误率与新权重,直至达到所需精度/错误率,或找到所需数量的特征。)

最终分类器是这些弱分类器的加权和。之所以称其为"弱",是因为单个分类器无法独立完成图像分类,但组合起来就构成了强分类器。论文指出:仅 200 个特征即可达到 95% 的检测精度,而其最终配置使用了约 6000 个特征(从 16 万多个特征精简到 6000 个特征,是巨大的收益)。

级联分类器(Cascade of Classifiers)

现在对一张图像做检测:取每个 24x24 窗口,套用 6000 个特征,判断是否为人脸——显然效率低下、耗时巨大。论文作者给出了很好的解决方案:图像中大部分区域不是人脸。更好的策略是先用一个简单方法判断窗口是否为人脸区域,若不是,则一次性丢弃、不再处理,把算力集中在可能存在人脸的区域。

为此,作者引入了 级联分类器(Cascade of Classifiers) 的概念:不再对每个窗口套用全部 6000 个特征,而是将特征按不同阶段(stage)分组,逐级套用(通常前几级只包含很少的特征)。若窗口未通过第一级,直接丢弃,不再考虑剩余特征;若通过,则进入第二级继续,直至通过所有级联阶段,该窗口才被认定为人脸区域。

作者的检测器包含 6000+ 特征、共 38 个阶段,前五个阶段分别包含 1、10、25、25、50 个特征。据作者统计,平均每个子窗口只需评估 6000+ 特征中的约 10 个。这就是 Viola-Jones 人脸检测工作原理的直观解释,更深入的内容可阅读原论文。

从仓库头文件 xobjdetect.hpp 的模块文档可以看出,这一检测器最初由 Viola 提出、后经 Rainer Lienhart 改进:分类器(即"基于 haar 特征的提升级联分类器")先用数百个某类对象(如人脸、汽车)的样本视图(称为正样本,缩放到统一尺寸如 20x20)以及任意同尺寸图像(负样本)训练而成;"级联"一词指最终分类器由多个更简单的分类器(阶段)依次作用在感兴趣区域上,直到某阶段拒绝候选或全部阶段通过;"提升(boosted)"指每一阶段自身也是由基本分类器通过四种提升技术之一(离散 Adaboost、Real Adaboost、Gentle Adaboost 与 Logitboost,当前均已支持)加权投票构建而成,基本分类器是至少含 2 个叶子的决策树分类器。

在 OpenCV 中使用 Haar 级联检测

OpenCV 提供了训练方法(见 级联分类器训练教程,对应 opencv_traincascade 工具),也提供了可直接用 cv::CascadeClassifier::load 读取的预训练模型。预训练模型位于 OpenCV 安装目录的 data 文件夹中,本仓库中则位于 modules/xobjdetect/data 下,具体包括:

  • haarcascades:Haar 特征分类器,如 haarcascade_frontalface_alt.xml、haarcascade_frontalface_default.xml、haarcascade_eye_tree_eyeglasses.xml、haarcascade_smile.xml、haarcascade_fullbody.xml 等;
  • lbpcascades:LBP 特征分类器,如 lbpcascade_frontalface.xml、lbpcascade_frontalface_improved.xml;
  • haarcascades_cuda:面向 CUDA 加速的 Haar 分类器副本;
  • hogcascades:行人检测 HOG 级联。

仓库 data/readme.txt 说明这些数据供 cv 库与示例程序使用,并提醒部分分类器具有特殊许可证,使用时请查看文件内的许可说明。

下面的示例代码将使用预训练的 Haar 级联模型,在图像中检测人脸与人眼。流程是:首先创建 cv::CascadeClassifier 对象,用 load 加载所需的 XML 文件;随后用 detectMultiScale 完成检测,返回检测到的人脸/人眼边界矩形。

C++ 示例

完整代码见 samples/objectDetection.cpp:

#include "opencv2/xobjdetect.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/videoio.hpp"
#include <iostream>

using namespace std;
using namespace cv;

/** Function Headers */
void detectAndDisplay( Mat frame );

/** Global variables */
CascadeClassifier face_cascade;
CascadeClassifier eyes_cascade;

/** @function main */
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;
}

/** @function detectAndDisplay */
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 );
}

代码要点:

  • 预处理:cvtColor 将帧转为灰度图,equalizeHist 做直方图均衡化以增强对比度、改善检测效果;
  • 人脸检测:face_cascade.detectMultiScale( frame_gray, faces ) 返回人脸矩形列表;
  • 人眼检测:对每个 faces[i] 提取感兴趣区域 faceROI = frame_gray( faces[i] ),再调用 eyes_cascade.detectMultiScale( faceROI, eyes ) —— 人眼只在人脸区域内搜索,既提升精度又降低计算量;
  • 绘制:人脸用品红色椭圆、人眼用蓝色圆标出,按 ESC(键值 27)退出。

Python 示例

完整代码见 samples/python/tutorial_code/objectDetection/cascade_classifier/objectDetection.py:

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

运行方式:

python objectDetection.py \
    --face_cascade data/haarcascades/haarcascade_frontalface_alt.xml \
    --eyes_cascade data/haarcascades/haarcascade_eye_tree_eyeglasses.xml \
    --camera 0

Java 示例

完整代码见 samples/java/tutorial_code/objectDetection/cascade_classifier/ObjectDetectionDemo.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.xobjdetect.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) {
        // Load the native OpenCV library
        System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

        new ObjectDetection().run(args);
    }
}

运行结果

Haar 分类器结果

以笔记本内置摄像头视频流为输入运行上述代码,得到如下结果:

使用 Haar 级联模型的人脸与人眼检测结果

请务必确保程序能够找到 haarcascade_frontalface_alt.xml 与 haarcascade_eye_tree_eyeglasses.xml 这两个文件的路径,它们位于仓库的 modules/xobjdetect/data/haarcascades 目录下(示例代码默认按 data/haarcascades/... 相对路径并通过 samples::findFile 解析)。

LBP 分类器结果

下面是人脸检测改用 LBP 训练的分类器文件 lbpcascade_frontalface.xml(位于 modules/xobjdetect/data/lbpcascades)后的结果,人眼检测仍使用教程中的 Haar 文件:

使用 LBP 级联模型的人脸检测结果

对比可见,Haar 与 LBP 两种特征均能完成人脸检测。从 训练教程 的说明可知:LBP 特征产生整数精度,而 Haar 特征产生浮点精度,因此 LBP 的训练与检测速度均比 Haar 快数倍;而两者检测质量主要取决于训练数据与训练参数——完全可以训练出与 Haar 质量几乎相同、而训练时间只占其很小比例的 LBP 分类器。

深入 detectMultiScale:从源码理解每个参数

示例中仅用了 detectMultiScale 的默认参数,而在实际工程中(尤其是检测小目标、遮挡目标或需要滤除误检时),理解各参数的意义至关重要。查看 xobjdetect.hpp 中该函数的完整签名:

CV_WRAP void detectMultiScale( InputArray image,
                      CV_OUT std::vector<Rect>& objects,
                      double scaleFactor = 1.1,
                      int minNeighbors = 3, int flags = 0,
                      Size minSize = Size(),
                      Size maxSize = Size() );

各参数说明(摘自头文件源码注释):

  • image:类型为 CV_8U 的输入图像矩阵,对象将在其中被检测;
  • objects:矩形输出向量,每个矩形包含一个检测到的对象,矩形可能部分超出原图像范围;
  • scaleFactor:指定每次图像尺度缩减多少的缩放系数(默认 1.1,即每层尺度缩小约 9%)。取值越小,尺度扫描越密、检测越充分,但计算量越大;
  • minNeighbors:每个候选矩形至少应拥有的邻居数量(默认 3),用于滤除孤立误检;值越大,误检越少,但可能漏检;
  • flags:对于旧格式分类器与 cvHaarDetectObjects 语义相同,新格式分类器不使用;
  • minSize:最小可能对象尺寸,小于该尺寸的对象被忽略;
  • maxSize:最大可能对象尺寸,大于该尺寸的对象被忽略;若 maxSize == minSize,模型将在单一尺度上评估。

头文件还提供了三个重载版本,可应对更精细的需求:

  • detectMultiScale2:额外输出 numDetections 向量,记录每个对象由多少个邻近的正分类矩形合并而成;
  • detectMultiScale3:额外输出 rejectLevels 与 levelWeights,当 outputRejectLevels 为 true 时,每个检测结果对应 levelWeights 中保存的最终阶段分类置信度,可用于区分强/弱分类结果,例如后续再按权重阈值二次过滤。

在 cascadedetect.cpp 中可以看到矩形合并的实现:groupRectangles 在 groupThreshold <= 0 或矩形列表为空时直接返回;否则通过聚类(partition)将尺寸与位置相近的矩形归组,剔除少于阈值的小簇,并对保留的簇输出平均矩形。这与检测流程中"多尺度滑窗 + 相邻矩形合并"的经典思路一致。

此外,头文件定义了检测标志枚举:

enum { CASCADE_DO_CANNY_PRUNE    = 1,
       CASCADE_SCALE_IMAGE       = 2,
       CASCADE_FIND_BIGGEST_OBJECT = 4,
       CASCADE_DO_ROUGH_SEARCH   = 8 };

CASCADE_DO_CANNY_PRUNE 表示用 Canny 边缘检测跳过明显无目标的区域;CASCADE_FIND_BIGGEST_OBJECT 只返回最大目标;CASCADE_SCALE_IMAGE 表示通过缩放图像而非缩放检测窗口来进行多尺度搜索。

从模块层面看,xobjdetect 的 CMakeLists.txt 声明该模块依赖 opencv_core、opencv_imgproc、opencv_imgcodecs、opencv_features,并支持 Python / Java / ObjC / JS 绑定;同时把 data 目录作为子目录随模块一并安装,这也是预训练 XML 能够随 OpenCV 安装目录分发的原因。模块的检测相关测试可见 test/test_cascadeandhog.cpp。

训练自己的级联分类器

本教程只负责"用现成模型做检测"。如果你想针对特定对象(例如自己的产品、特定姿态、特定物体)训练级联分类器,仓库配套的 级联分类器训练教程 会引导你完成:收集训练数据、准备正负样本、执行模型训练三个完整阶段,使用 opencv_createsamples、opencv_annotation、opencv_traincascade 与 opencv_visualisation 等官方工具。

需要留意(该教程中的官方提示):自 OpenCV 4.0 起 createsamples 与 traincascade 已被禁用,如需训练级联分类器,建议使用 3.4 分支的这两个工具——3.4 与 4.x 的模型格式一致,训练产物可直接被本教程所述接口加载。

延伸阅读

  1. Paul Viola and Michael J. Jones. Robust real-time face detection. International Journal of Computer Vision, 57(2):137–154, 2004.
  2. Rainer Lienhart and Jochen Maydt. An extended set of haar-like features for rapid object detection. In Image Processing. 2002. Proceedings. 2002 International Conference on, volume 1, pages I–900. IEEE, 2002.
  3. 若对训练细节感兴趣,可直接阅读仓库中的 traincascade 教程,它涵盖了正负样本的构造规范、bg.txt 背景描述文件格式以及训练参数的完整说明。
登录后查看全文
opencv_contrib