88

我一直在实施Viola-Jones 的人脸检测算法的改编版。该技术依赖于在图像中放置一个 24x24 像素的子帧,然后将矩形特征放置在图像中的每个位置,并具有各种可能的大小。

这些特征可以由两个、三个或四个矩形组成。给出了以下示例。

矩形特征

他们声称详尽的集合超过 180k(第 2 节):

鉴于检测器的基本分辨率为 24x24,详尽的矩形特征集相当大,超过 180,000 个。请注意,与 Haar 基不同,矩形特征集是过完备的。

以下陈述未在论文中明确说明,因此它们是我的假设:

  1. 只有 2 个二矩形特征、2 个三矩形特征和 1 个四矩形特征。这背后的逻辑是我们正在观察突出显示的矩形之间的差异,而不是明确地观察颜色或亮度或任何类似的东西。
  2. 我们不能将特征类型 A 定义为 1x1 像素块;它必须至少为 1x2 像素。此外,类型 D 必须至少为 2x2 像素,并且此规则适用于其他特征。
  3. 我们不能将特征类型 A 定义为 1x3 像素块,因为中间像素无法分割,从自身中减去它与 1x2 像素块相同;此特征类型仅针对偶数宽度定义。此外,特征类型 C 的宽度必须能被 3 整除,此规则也适用于其他特征。
  4. 我们无法定义宽度和/或高度为 0 的特征。因此,我们将xy迭代为 24 减去特征的大小。

基于这些假设,我计算了详尽的集合:

const int frameSize = 24;
const int features = 5;
// All five feature types:
const int feature[features][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};

int count = 0;
// Each feature:
for (int i = 0; i < features; i++) {
    int sizeX = feature[i][0];
    int sizeY = feature[i][1];
    // Each position:
    for (int x = 0; x <= frameSize-sizeX; x++) {
        for (int y = 0; y <= frameSize-sizeY; y++) {
            // Each size fitting within the frameSize:
            for (int width = sizeX; width <= frameSize-x; width+=sizeX) {
                for (int height = sizeY; height <= frameSize-y; height+=sizeY) {
                    count++;
                }
            }
        }
    }
}

结果是162,336

我发现近似 Viola & Jones 所说的“超过 180,000 个”的唯一方法是放弃假设 #4 并在代码中引入错误。这涉及将四行分别更改为:

for (int width = 0; width < frameSize-x; width+=sizeX)
for (int height = 0; height < frameSize-y; height+=sizeY)

结果是180,625。(请注意,这将有效地防止特征接触子框架的右侧和/或底部。)

现在当然是问题:他们在实施过程中犯了错误吗?考虑表面为零的特征是否有意义?还是我看错了?

4

6 回答 6

41

仔细一看,你的代码对我来说是正确的;这让人想知道原始作者是否有一个错误的错误。我想有人应该看看 OpenCV 是如何实现它的!

尽管如此,一个更容易理解的建议是通过首先遍历所有大小来翻转for循环的顺序,然后遍历给定大小的可能位置:

#include <stdio.h>
int main()
{
    int i, x, y, sizeX, sizeY, width, height, count, c;

    /* All five shape types */
    const int features = 5;
    const int feature[][2] = {{2,1}, {1,2}, {3,1}, {1,3}, {2,2}};
    const int frameSize = 24;

    count = 0;
    /* Each shape */
    for (i = 0; i < features; i++) {
        sizeX = feature[i][0];
        sizeY = feature[i][1];
        printf("%dx%d shapes:\n", sizeX, sizeY);

        /* each size (multiples of basic shapes) */
        for (width = sizeX; width <= frameSize; width+=sizeX) {
            for (height = sizeY; height <= frameSize; height+=sizeY) {
                printf("\tsize: %dx%d => ", width, height);
                c=count;

                /* each possible position given size */
                for (x = 0; x <= frameSize-width; x++) {
                    for (y = 0; y <= frameSize-height; y++) {
                        count++;
                    }
                }
                printf("count: %d\n", count-c);
            }
        }
    }
    printf("%d\n", count);

    return 0;
}

与之前的结果相同162336


为了验证它,我测试了 4x4 窗口的情况并手动检查了所有情况(很容易计算,因为 1x2/2x1 和 1x3/3x1 形状相同,仅旋转 90 度):

2x1 shapes:
        size: 2x1 => count: 12
        size: 2x2 => count: 9
        size: 2x3 => count: 6
        size: 2x4 => count: 3
        size: 4x1 => count: 4
        size: 4x2 => count: 3
        size: 4x3 => count: 2
        size: 4x4 => count: 1
1x2 shapes:
        size: 1x2 => count: 12             +-----------------------+
        size: 1x4 => count: 4              |     |     |     |     |
        size: 2x2 => count: 9              |     |     |     |     |
        size: 2x4 => count: 3              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x4 => count: 2              |     |     |     |     |
        size: 4x2 => count: 3              +-----+-----+-----+-----+
        size: 4x4 => count: 1              |     |     |     |     |
3x1 shapes:                                |     |     |     |     |
        size: 3x1 => count: 8              +-----+-----+-----+-----+
        size: 3x2 => count: 6              |     |     |     |     |
        size: 3x3 => count: 4              |     |     |     |     |
        size: 3x4 => count: 2              +-----------------------+
1x3 shapes:
        size: 1x3 => count: 8                  Total Count = 136
        size: 2x3 => count: 6
        size: 3x3 => count: 4
        size: 4x3 => count: 2
2x2 shapes:
        size: 2x2 => count: 9
        size: 2x4 => count: 3
        size: 4x2 => count: 3
        size: 4x4 => count: 1
于 2009-11-10T21:02:39.690 回答
9

全部。Viola 和 Jones 的论文中仍然存在一些混乱。

在他们的 CVPR'01 论文中明确指出

“更具体地说,我们使用三种 特征。 两个矩形特征的值是两个矩形区域内像素之和的差值。这些区域具有相同的大小和形状,并且水平或垂直相邻(见图1). 三矩形特征计算两个外部矩形内的总和减去中心矩形的总和。最后是一个四矩形特征“。

在 IJCV'04 论文中,也说了同样的话。因此,总共有 4 个功能。但奇怪的是,他们这次表示详尽的功能集是 45396!那似乎不是最终版本。这里我猜想那里引入了一些额外的约束,例如 min_width、min_height、宽/高比,甚至是位置。

请注意,这两篇论文都可以在他的网页上下载。

于 2010-07-21T12:42:54.307 回答
3

没有读完整篇论文,你引述的措辞让我印象深刻

鉴于检测器的基本分辨率为 24x24,详尽的矩形特征集相当大,超过 180,000 个。请注意,与 Haar 基不同,矩形特征集是过完备的。

“矩形特征集过度完备” “穷举集”

在我看来,这听起来像是一个设置,我希望论文作者跟进解释他们如何将搜索空间缩减为更有效的集合,例如,通过摆脱诸如零的矩形之类的琐碎情况表面积。

编辑:或使用某种机器学习算法,作为抽象提示。穷举集意味着所有可能性,而不仅仅是“合理”的可能性。

于 2009-11-10T12:50:09.653 回答
2

无法保证任何论文的任何作者的所有假设和发现都是正确的。如果您认为假设 #4 是有效的,那么请保留该假设,并尝试您的理论。你可能比原作者更成功。

于 2009-11-10T13:00:39.170 回答
1

在他们最初的 2001 年论文中,他们只声明他们使用了三种特征:

我们使用三种特征

分别有两个、三个和四个矩形。

由于每种类型都有两个方向(相差 90 度),也许为了计算他们使用 2*3 类型的特征的总特征数:2 个二矩形特征、2 个三矩形特征和 2 个四矩形特征. 有了这个假设,确实有超过 180,000 个特征:

feature_types = [(1,2), (2,1), (1,3), (3,1), (2,2), (2,2)]
window_size = (24,24)

total_features = 0
for f_type in feature_types:
    for f_height in range(f_type[0], window_size[0] + 1, f_type[0]):
        for f_width in range(f_type[1], window_size[1] + 1, f_type[1]):
            total_features += (window_size[0] - f_height + 1) * (window_size[1] - f_width + 1)
            
print(total_features)
# 183072

第二个四矩形特征与第一个仅相差一个符号,因此无需保留它,如果我们删除它,那么特征总数将减少到 162,336。

于 2020-06-23T08:55:50.827 回答
1

很好的观察,但他们可能会隐含地对 24x24 帧进行零填充,或“溢出”并在超出范围时开始使用第一个像素,例如旋转移位,或者正如 Breton 所说,他们可能会将某些特征视为“微不足道的特征”然后用 AdaBoost 丢弃它们。

此外,我编写了您的代码的 Python 和 Matlab 版本,因此我可以自己测试代码(对我来说更容易调试和遵循),所以如果有人发现它们有时有用,我会将它们发布在这里。

Python:

frameSize = 24;
features = 5;
# All five feature types:
feature = [[2,1], [1,2], [3,1], [1,3], [2,2]]

count = 0;
# Each feature:
for i in range(features):
    sizeX = feature[i][0]
    sizeY = feature[i][1]
    # Each position:
    for x in range(frameSize-sizeX+1):
        for y in range(frameSize-sizeY+1):
            # Each size fitting within the frameSize:
            for width in range(sizeX,frameSize-x+1,sizeX):
                for height in range(sizeY,frameSize-y+1,sizeY):
                    count=count+1
print (count)

MATLAB:

frameSize = 24;
features = 5;
% All five feature types:
feature = [[2,1]; [1,2]; [3,1]; [1,3]; [2,2]];

count = 0;
% Each feature:
for ii = 1:features
    sizeX = feature(ii,1);
    sizeY = feature(ii,2);
    % Each position:
    for x = 0:frameSize-sizeX
        for y = 0:frameSize-sizeY
            % Each size fitting within the frameSize:
            for width = sizeX:sizeX:frameSize-x
                for height = sizeY:sizeY:frameSize-y
                    count=count+1;
                end
            end
        end
    end
end

display(count)
于 2017-04-12T18:06:29.287 回答