opencv 学习笔记-入门（22）之快速hog的减少取样实现-论文笔记

最新推荐文章于 2022-06-03 14:33:39 发布
最新推荐文章于 2022-06-03 14:33:39 发布
阅读量2k 收藏 1
点赞数
分类专栏： opencv算法学习 文章标签： transformation each types c algorithm features
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wobuaishangdiao/article/details/7751598
版权

[Pang, 2011] Y. Pang, Y. Yuan, X. Li, et al. Efficient HOG human detection [J]. Signal Processing, 2011, 91: 773-781.  阅读笔记 

We call this method as cell-based trilinear interpolation.


To decrease the computation complexity, we develop a sub-cell based trilinear interpolation. 

 The proposed method avoids unimportant interpolation by omitting the gradients whose locations are far from the cell (sub-cell) in concern. Specifically, each cell (8×8 pixels) in a block (16×16 pixels) is divided into 4 sub-cells (there are 4×4 pixels in a sub-cell). We classify the 4 sub-cells into 3 types: corner sub-cell, inner sub-cell, and semi-inner sub-cell. As illustrated in Fig. 4, a block contains 4 cells: C1, C2, C3, and C4 (see Fig. 4(a)) and Ci contains 4 sub-cells: Ci1, Ci2, Ci3, and Ci4 (see Fig. 4(b)). Note from Fig. 4(c) that C11, C22, C33, and C44 are called corner sub-cells, C14,C23, C41, andC32 are called inner sub-cells, and C12, C21, C24, C42, C43, C34, C31, and C13 are called semi-inner sub-cells. In our algorithm the 3 types of sub-cells have different roles in computing the HOG features:

(1)

Because that the corner sub-cells are at the corners of a block and are far from the other 3 cells, the gradients in the corner sub-cells are merely used to compute the histogram corresponding to their own cells. That is, the gradients in C11, C22, C33, and C44 contribute only to the histograms of C1, C2, C3, and C4, respectively.

(2)

Because that the inner sub-cells are near to all the 4 cells, so we let the gradients in the inner sub-cells to contribute to the histograms of all the 4 cells.

(3)

Each semi-inner sub-cell in a cell is a neighbor of a unique cell. Therefore, the gradients in each semi-inner cell are involved in computing the histograms of its own cell and its neighbor cell. Take the semi-inner cell C13 for example, C13 is contained in C1 and is a neighbor of C3. So the gradients in C13 are used for computing the histograms of C1 and C3, but they are independent to the histograms of C2 and C4.

Fig. 4. Sub-cell based representation: (a) a 16×16 block consisting of four 8×8 cells: C1, C2, C3, and C4. (b) Each 8×8 cell Ci is decomposed into 4 sub-cells: Ci1, Ci2, Ci3, and Ci4, which have 3 types: corner sub-cell, inner sub-cell, and semi sub-cell.



Let h1 denote the HOG features of cell C1. Mathematically loosing, the computation of h1 is given by




3.3. Efficient implementation of pixel based interpolation

Now the question is how to compute the item hist(Cij) of Eq. (6). A straightforward way is to utilize Eqs.(1) and (2) to calculate each bin of hist(Cij). According to Eqs. (1) and (2), the contribution of gradient at location (x,y) to orientation θ2 is given by

(8)
where the coefficients are
(9)
(10)
(11)

Generally, it is time-consuming to compute Eq. (8) because it has to calculate the coefficients.

To speed up the computation process, we propose to compute the coefficients a and b offline and save them to a look-up-table. Given (x,y) the coefficients a and b can be obtained by the look-up-table. Note that the coefficient c cannot be computed by the look-up-table trick because the value of θ(x,y) is continuous instead of discrete. Using the look-up-table, computing Eq. (8) requires only 4 multiplications and 1 addition.

It is worth noting that Wang et al. [27] proposed to estimate Eq. (8) by convolving the gradients at (x,y) with the following 7 by 7 kernel:

(12)

Throughout this paper we call this method “convolution method” [27]. The convolution takes 50 multiplications and 49 additions. Even with fast Fourier transformation (FFT) the process takes more operations than our proposed look-up-table method. But the convolution method can be integrated with the trick of integral image [16], so it is faster than the traditional HOG method [10].


三线插值实现代码：

//三线插值  //针对快速实现的方法
void calHogBlock(Mat& grad_ang, Point btl, float *votes)   //btl就是每个块每个块的头坐标
{
	static double *gaussmask = getGaussMask();
	
	int x = btl.x;
	int y = btl.y;
	int index_x, index_y, index_z;
	for (int i = 0; i < parm.block * parm.cell; i++)  //一个block 的一维的长度
	{
		for (index_x = 0; index_x < 2; index_x++)     //索引cell
		{
			if ((i - parm.mid[index_x]) < 0)          //要在那两个cell的右边
				break;
		}
		float *gpd = grad_ang.ptr<float>(x+i);        //在这个基础上的第几行
		double *spd = gaussmask + i*16; // i*parm.block*parm.cell; //每一行的第一个的指针
		for (int j = 0; j < parm.block * parm.cell; j++)  
		{
			float temp = gpd[(j + y) * 2];  //每个的grident的值
			float angle = gpd[(j + y) * 2 + 1];   //*2 表示通道数
			for (index_y = 0; index_y < 2; index_y++)  //cell 的列坐标
			{
				if ((j - parm.mid[index_y]) < 0)
					break;
			}
			for (index_z = 0; index_z < DIR; index_z++)  //维度
			{
				if ((angle - dirs[index_z]) < 0)    //找到他所在的那个区间，然后进行投影
					break;   //angle比那个小的一个，即在那个比angle大一个的那个区段上限
			}

			float weight = float(spd[j] * temp);  
			float x_interpolate = (float)(i-parm.mid[0]) / parm.cell;  //插值的权重
			float y_interpolate = (float)(j-parm.mid[0])/ parm.cell;   //插值的权重
			float z_interpolate = (float)(dirs[index_z] - angle) * DIR/PI;   //

			if (index_x == 0)   
			{
				if (index_y == 0)
				{
					if (index_z == 0)
					{
						votes[0] += weight;     //
					}
					else if(index_z == 9)
					{
						votes[8] += weight;
					}
					else
					{	
						votes[index_z-1] += weight * (1-z_interpolate); 
						votes[index_z] += weight * z_interpolate;
					}
				}
				else if (index_y == 1)
				{
					if (index_z == 0)
					{
						votes[0] += weight * y_interpolate;
						votes[DIR] += weight * (1 - y_interpolate);
					}
					else if(index_z == 9)
					{
						votes[8] += weight * y_interpolate;
						votes[DIR+8] += weight * (1 - y_interpolate);
					}
					else
					{
						votes[index_z-1] += weight * y_interpolate * (1-z_interpolate);
						votes[index_z] += weight * y_interpolate * z_interpolate;
						votes[DIR+index_z-1] += weight * (1 - y_interpolate) * (1 - z_interpolate);
						votes[DIR+index_z] += weight * (1 - y_interpolate) * z_interpolate;
					}
				}
				else   //index_y = 2
				{
					if (index_z == 0)
					{
						votes[DIR] += weight;
					}
					else if(index_z == 9)
					{
						votes[DIR+8] += weight;
					}
					else
					{
						votes[DIR+index_z-1] += weight * (1 - z_interpolate);
						votes[DIR+index_z] += weight * z_interpolate;
					}
				}
			}
			else if(index_x == 1)
			{
				if (index_y == 0)
				{
					if (index_z == 0)
					{
						votes[0] += weight * x_interpolate;
						votes[parm.block * DIR] += weight * (1 - x_interpolate);
					}
					else if(index_z == 9)
					{
						votes[8] += weight * x_interpolate;
						votes[parm.block * DIR + 8] += weight * (1 - x_interpolate);
					}
					else
					{
						votes[index_z-1] += weight * x_interpolate * (1-z_interpolate);
						votes[index_z] += weight * x_interpolate * z_interpolate;
						votes[parm.block * DIR + index_z-1] += weight * (1-x_interpolate) * (1-z_interpolate);
						votes[parm.block * DIR + index_z] += weight * (1-x_interpolate) * z_interpolate;
					}
				}
				else if (index_y == 1)
				{
					if (index_z == 0)
					{
						votes[0] += weight * x_interpolate * y_interpolate;
						votes[DIR] += weight * x_interpolate * (1-y_interpolate);
						votes[parm.block * DIR] += weight * (1-x_interpolate) * y_interpolate;
						votes[parm.block * DIR + DIR] += weight * (1-x_interpolate) * (1-y_interpolate);
					}
					else if(index_z == 9)
					{
						votes[8] += weight * x_interpolate * y_interpolate;
						votes[DIR + 8] += weight * x_interpolate * (1-y_interpolate);
						votes[parm.block * DIR + 8] += weight * (1-x_interpolate) * y_interpolate;
						votes[parm.block * DIR + DIR + 8] += weight * (1-x_interpolate) * (1-y_interpolate);
					}
					else
					{
						votes[index_z-1] += weight * x_interpolate * y_interpolate * (1-z_interpolate);
						votes[index_z] += weight * x_interpolate * y_interpolate * z_interpolate;
						votes[DIR+index_z-1] += weight * x_interpolate * (1-y_interpolate) * (1-z_interpolate);
						votes[DIR+index_z] += weight * x_interpolate * (1-y_interpolate) * z_interpolate;
						votes[parm.block * DIR+index_z-1] += weight * (1-x_interpolate) * y_interpolate * (1-z_interpolate);
						votes[parm.block * DIR+index_z] += weight * (1-x_interpolate) * y_interpolate * z_interpolate;
						votes[parm.block * DIR+DIR+index_z-1] += weight * (1-x_interpolate) * (1-y_interpolate) * (1-z_interpolate);
						votes[parm.block * DIR+DIR+index_z] += weight * (1-x_interpolate) * (1-y_interpolate) * z_interpolate;
					}
				}
				else
				{
					if (index_z == 0)
					{
						votes[DIR] += weight * x_interpolate;
						votes[parm.block * DIR + DIR] += weight * (1-x_interpolate);
					}
					else if(index_z == 9)
					{
						votes[8+DIR] += weight * x_interpolate;
						votes[parm.block * DIR+ DIR+8] += weight * (1-x_interpolate);
					}
					else
					{
						votes[DIR+index_z-1] += weight * x_interpolate * (1-z_interpolate);
						votes[DIR+index_z] += weight * x_interpolate * z_interpolate;
						votes[parm.block * DIR+DIR+index_z-1] += weight * (1-x_interpolate) * (1-z_interpolate);
						votes[parm.block * DIR+DIR+index_z] += weight * (1-x_interpolate) * z_interpolate;
					}
				}
			}
			else
			{
				if (index_y == 0)
				{
					if (index_z == 0)
					{
						votes[parm.block * DIR] += weight;
					}
					else if(index_z == 9)
					{
						votes[parm.block * DIR+8] += weight;
					}
					else
					{
						votes[parm.block * DIR+index_z-1] += weight * (1-z_interpolate);
						votes[parm.block * DIR+index_z] += weight * z_interpolate;
					}
				}
				else if (index_y == 1)
				{
					if (index_z == 0)
					{
						votes[parm.block * DIR] += weight * y_interpolate;
						votes[parm.block * DIR + DIR] += weight * (1-y_interpolate);
					}
					else if(index_z == 9)
					{
						votes[parm.block*DIR+8] += weight * y_interpolate;
						votes[parm.block*DIR+DIR+8] += weight * (1-y_interpolate);
					}
					else
					{
						votes[parm.block*DIR+index_z-1] += weight * y_interpolate * (1-z_interpolate);
						votes[parm.block*DIR+index_z] += weight * y_interpolate * z_interpolate;
						votes[parm.block*DIR+DIR+index_z-1] += weight * (1-y_interpolate) * (1-z_interpolate);
						votes[parm.block*DIR+DIR+index_z] += weight * (1-y_interpolate) * z_interpolate;
					}
				}
				else
				{
					if (index_z == 0)
					{
						votes[parm.block*DIR+DIR] += weight;
					}
					else if(index_z == 9)
					{
						votes[parm.block*DIR+DIR+9] += weight;
					}
					else
					{
						votes[parm.block*DIR+DIR+index_z-1] += weight * (1-z_interpolate);
						votes[parm.block*DIR+DIR+index_z] += weight * z_interpolate;
					}
				}
			}
		}
	}
	
	
	normL2(votes);
	
}



wobuaishangdiao
关注
专栏目录
[Python从零到壹] 七十七.图像识别及经典案例篇之目标检测入门普及和ImageAI对象检测详解
杨秀璋的专栏
04-28 933
前文介绍了人脸检测的应用案例，通过OpenCV快速实现人脸检测。这篇文章将详细讲解目标检测基础知识，并通过ImageAI实现对象检测的经典案例。本文主要介绍目标检测原理，通过七个问题来普及什么是目标检测。然后利用ImageAI实现最简单的目标检测案例，加深读者的印象，本文提供的案例将为读者提供深入的理解，希望您喜欢。
Opencv学习笔记 - OpenCV 4机器学习算法简介
学以致用 知行合一
11-16 5066
在机器学习中，一些比较流行方法的包括：支持向量机（SVM）、人工神经网络（ANN）、聚类、k-最近邻、决策树和深度学习。OpenCV支持并实现几乎所有这些方法，并有详细的文档说明。 OpenCV 4 机器学习算法 OpenCV实现了其中的八种机器学习算法，所有这些算法都继承自StatModel类，这八种算法是： ·人工神经网络 ·随机树 ·期望最大化 ·k-最近邻 ·............
opencv 学习笔记-入门（30）hog+svm 的实现
07-23 2971
一.想要做行人检测，必须要看的一篇论文《Histograms of Oriented Gradients for Human Detection》为Dalal和Bill Triggs的经典之作。 主要实现的流程为                                     （1）首先提取图片进行图片的 gamma compression 这样是图片的表面得到变换，其中可采用s
【youcans的OpenCV例程300篇】总目录
热门推荐
youcans的博客
06-03 6万+
【youcans 的 OpenCV 例程300篇】总目录 转载本系列作品时必须标注以下版权内容：必须标注以下版权内容： youcans@qq.com, 【youcans 的 OpenCV 例程】, https://blog.csdn.net/youcans/category_11459626.html......................................................
CV学习笔记 | CV综述 [2020.10.01]
不愿透露姓氏的王先生
01-26 6632
文章目录0.概述（整理完后随时修改）1.人工神经网络1.1.人工神经网络发展历程1.2.一些神经元节点的工作原理 内容简述： 关于NN发展历程 CNN架构 … 说明： 学习笔记内容整理自网络 0.概述（整理完后随时修改） 本文第一章简要回顾了人工神经网络自1998年以来模型的发展历程，并介绍了神经元节点的工作原理，引出26个(现存)神经元网络模型。该部分内容主要参见自： NEURAL NETWORK ZOO PREQUEL: CELLS NAD LAYERS THE NEURAL NETWOR
结合opencv学习DIP
Heisenberg's blog
02-24 709
imread()加载图像 imread加载图像文件成为Mat对象 imread（图像文件名，图像类型，p3） p3是附加操作 IMREAD_UNCHANGED(<0)不做改变加载图像 IMREAD_GRAYSCALE(0)原图作为灰度图像加载进来 IMREAD_COLOR(>0)原图作为RGB图像加载进来 namedWindow 创建一个ope...
【行为识别】论文阅读笔记1|Two-Stream Convolutional Networks for Action Recognition in Videos
Cheungleilei的博客
10-28 2509
参考山水之间2018的文章， 行为识别（Action Recognition） 的目的是对一个给定的视频片段进行分类。 行为检测（Action Detection） 的目的是知道一个动作在视频中是否发生，以及动作发生在视频中的开始时间和结束时间。 行为识别和行为检测的关系类似于图片分类和目标检测的关系。 目前行为识别有两个主流的结构，一个是Two-Stream，一个是C3D，本文阅读了Two-St...
【目标检测】R-CNN笔记
zkddt的博客
10-15 640
参考博客：https://blog.csdn.net/briblue/article/details/82012575 作者：frank909 一、背景摘要 R-CNN经典论文的题目是 《Rich feature hierarchies for accurate oject detection and semantic segmentation》，翻译过来就是针对高准确度的目标检测与语义分割...
Deep Learning（深度学习）学习笔记整理系列
sdulibh的专栏
08-19 4421
一、概述        Artificial Intelligence，也就是人工智能，就像长生不老和星际漫游一样，是人类最美好的梦想之一。虽然计算机技术已经取得了长足的进步，但是到目前为止，还没有一台电脑能产生“自我”的意识。是的，在人类和大量现成数据的帮助下，电脑可以表现的十分强大，但是离开了这两者，它甚至都不能分辨一个喵星人和一个汪星人。        图灵（图灵，大家都知道吧。
论文阅读笔记（四）——基于深度卷积神经网络的多视角人脸检测
weixin_52777338的博客
05-06 1820
论文阅读笔记（四）——基于深度卷积神经网络的多视角人脸检测 论文简介 论文中文翻译：《基于深度卷积神经网络的多视角人脸检测》 论文名称：《Multi-view Face Detection Using Deep Convolutional Neural Networks》 期刊情况 期刊： 期刊情况： 中科院 影响因子 分区 审稿 摘要 本文考虑多视角人脸检测问题。虽然已经对这个问题进行了大量的研究，但是当前用于该任务的最先进的方法需要面部标志的注释，例如TSM [25]，或者面部姿态的注释[28，22
OpenCv入门学习笔记.pdf
02-11
opencv入门学习文档，是根据个人学习记录的笔记总计三百多页，内含书签，文档简洁适合快速入门，了解图像处理，视频跟踪，神经网络等概念和基本原理，以及人脸识别案例在Opencv中的实现，内含了C++实现源代码。
C++下OpenCV学习笔记 ----图像叠加与混合
X_To_Y的博客
02-20 5896
C++下OpenCV学习笔记 ----图像叠加与混合 文章目录 一.感兴趣区域：ROI 二.线性混合操作 三.计算数组的加权和：addWeighted函数 四.颜色通道的分离与合并 五.图像的亮度和对比度
opencv学习笔记-入门（16）人脸检测、跟踪与人脸识别
06-22 1万+
一、背景知识 （1）从main入手的对原人脸检测历程进行了参考以及开进， vector names;定义的矢量string组，它和直接定义的数组相比，可以对矢量的长度单元进行相应的增加和减少。因而它是更利于存储一些未知的组数据的。 （2） _finddata_t file;这个变量的定义用来存储文件的各种信息，便于之后的文件的查找应用，在之后的识别过程中会用到。 那么到底如何查找
opencv学习笔记-入门（25）Mat 的学习
07-17 1万+
（一）Mat矩阵中数据指针Mat.data是uchar类型指针，CV_8U系列可以通过计算指针位置快速地定位矩阵中的任意元素。 二维单通道元素可以用Mat::at(i, j)访问，i是行序号，j是列序号。 但对于多通道的非unsigned char类型矩阵来说，以上方法都不好（注：后来知道可以通过类型转换，用指针访问data数据，见后文）。可以用Mat::ptr()来获得指向某行元素的
opencv学习笔记-入门（10）皮肤检测与克服光线影响的连通域寻找
06-17 1万+
一 、背景知识：（自己看这块的一些笔记）     （1）数字电视的色彩空间和计算机不同，不是RGB空间，而是采用一个亮度信号(Y)和两个色差信号(R-Y、B-Y)的YUV空间或者叫YCbCr空间。数字电视采用YUV(YCbCr)色彩空间的原因主要就是为了减少数据储存空间和数据传输带宽，同时又能非常方便的兼容黑白电视(R-Y和B-Y信号为零)     （2）来源上的差异 yuv色彩模型来源
opencv 学习笔记-入门（21）之三线性插值-hog(二)
07-16 6635
图 1.         所谓的三线性插值指的是在(x,y,theta)这三个参数空间中进行插值，即x方向、y方向和梯度的角度空间，如图1所示，图中的象素点(x,y)在利用梯度幅值作为权重进行投票时，要根据该象素点距离其他格子中心的距离进行加权，同时该象素点的梯度方向也要在其相邻的区间内进行插值，用数学公式描述如下式所示。
opencv学习笔记-入门（32）264文件解码即YUV420文件格式图像的显示
08-08 6119
1.要实现的目的是远程视频监控，实现了由ARM板采集的编码视频回传到服务器上，但是出现一个问题由264编码文件的格式为YUV420编码格式文件，用它进行处理时，会出现很大的问题，编码文件的提醒。需要进行解码。 2.找到了H264的编解码源码，进行解码操作。首先找到主函数，寻找其读取文件的接口，在ldecod.c文件中， Configure函数下，找到了文件接口，并且利用这个进行了解码，
opencv学习笔记—入门（27）之高斯核单、双维的构造函数
07-19 6065
CvMat* GaussianKernel2D(int dim, float sigma) { CvMat* mat=cvCreateMat(dim, dim, CV_32FC1); CvMat* mat1=cvCreateMat(dim, dim, CV_32FC1); CvMat* mat2=cvCreateMat(dim, dim, CV_32FC1); #define
opencv学习笔记-入门（36）Meanshift，聚类算法
08-14 4696
【转载】 记得刚读研究生的时候，学习的第一个算法就是meanshift算法，所以一直记忆犹新，今天和大家分享一下Meanshift算法，如有错误，请在线交流。 Mean Shift算法,一般是指一个迭代的步骤,即先算出当前点的偏移均值,移动该点到其偏移均值,然后以此为新的起始点,继续移动,直到满足一定的条件结束.  1. Meanshift推导 给定d维空间Rd的n个样
openCV学习笔记----深入理解高斯滤波（二）
最新发布
06-11
好的，你的第一个问题是关于 OpenCV 中的高斯滤波的学习笔记，对吧？没问题，我可以为您提供一些关于高斯滤波的深入理解。 高斯滤波是一种常用的图像滤波器，它可以平滑图像并降低噪声。它的基本思想是对图像中的每...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值