积分图像与积分直方图

最新推荐文章于 2023-12-10 18:03:15 发布

_menglan_Zi

最新推荐文章于 2023-12-10 18:03:15 发布

阅读量1.5k

点赞数

分类专栏： cvpr 文章标签： Integral Image Integral Histogram

cvpr 专栏收录该内容

36 篇文章 0 订阅

订阅专栏

转载：（本文所有权由原作者所有）

http://blog.csdn.net/zhazhiqiang/article/details/18769195

http://blog.sina.com.cn/s/blog_679e132901011cph.html

****************************************************************************

积分直方图是有Fatih Porikli在CVPR-2005《Integral Histogram: A Fast Way to Extract Histograms in Cartesian Spaces》的论文中提到的。

在介绍积分直方图之前，先介绍下积分图像，积分图像是P.Viola and M.Jones "Robust real-time face detection " (ICCV 2001)中提到的。

一、积分图像

对于一幅灰度的图像，积分图像中的任意一点(x,y)的值是指从图像的左上角到这个点的所构成的矩形区域内所有的点的灰度值之和：

在实际的计算过程中，对于一个点(x,y)的值等于:

I(x,y)=I(x-1,y)+I(y-1,x)-I(x-1,y-1)+G(i,j) (I:该点的积分图像值，G:该点的灰度值）

在实际的编程实现过程中可以对有图像的大小进行扩展，左边扩展一列，顶端扩展一行,

即：I(-1,j)=0,I(i,-1)=0;

在完成上述计算后，就可以计算图像中任意矩形框的内点的灰度和：

二、积分直方图

同积分图像类似，统计的区域不再是所有像素点的灰度和，而是这个区域内所有像素的直方图，例如：从图像的左上角的起点到图像的右下角统计的就是这幅图像的直方图。如上图所示的对于D点就是统计的由原点O和D点构成的矩形区域的直方图。

****************************************************************************

方向梯度直方图（Histograms of Oriented Gradients，简称HOG特征）

结合支持向量机（ support vector machine，简称SVM），被广泛应用于图像识别中，尤其在行人检测中获得了极大的成功。积分直方图可以用于快速计算原始图像矩形区域内的HOG特征。积分直方图的概念类似与viola和jones在脸部识别中所用的积分图像。下面的代码给出了，对于一幅给定的图像，如何快速计算积分直方图，以及如何使用其进行HOG特征的演算（关键处以给出注释）：

/*Function to calculate the integral histogram*/  
IplImage** calculateIntegralHOG(IplImage* in)  
{  
    /*Convert the input image to grayscale*/  
    IplImage* img_gray = cvCreateImage(cvGetSize(in), IPL_DEPTH_8U,1);  
    cvCvtColor(in, img_gray, CV_BGR2GRAY);  
    cvEqualizeHist(img_gray,img_gray);  
  
/*Calculate the derivates of the grayscale image in the x and y directions using a sobel operator and obtain 2 gradient images for the x and y directions*/  
  
    IplImage *xsobel, *ysobel;  
    xsobel = doSobel(img_gray, 1, 0, 3);  
    ysobel = doSobel(img_gray, 0, 1, 3);  
    cvReleaseImage(&img_gray);  
  
  
/* Create an array of 9 images (9 because I assume bin size 20 degrees and unsigned gradient ( 180/20 = 9), one for each bin which will have zeroes for all pixels, except for the pixels in the original image for which the gradient values correspond to the particular bin. These will be referred to as bin images. These bin images will be then used to calculate the integral histogram, which will quicken the calculation of HOG descriptors */  
  
    IplImage** bins = (IplImage**) malloc(9 * sizeof(IplImage*));  
    for (int i = 0; i < 9 ; i++) {  
        bins[i] = cvCreateImage(cvGetSize(in), IPL_DEPTH_32F,1);  
        cvSetZero(bins);  
    }  
  
  
/* Create an array of 9 images ( note the dimensions of the image, the cvIntegral() function requires the size to be that), to store the integral images calculated from the above bin images. These 9 integral images together constitute the integral histogram */  
  
    IplImage** integrals = (IplImage**) malloc(9 * sizeof(IplImage*));   
    for (int i = 0; i < 9 ; i++) {  
        integrals[i] = cvCreateImage(cvSize(in->width + 1, in->height + 1),  
        IPL_DEPTH_64F,1);  
    }  
  
/* Calculate the bin images. The magnitude and orientation of the gradient at each pixel is calculated using the xsobel and ysobel images.{Magnitude = sqrt(sq(xsobel) + sq(ysobel) ), gradient = itan (ysobel/xsobel) }. Then according to the orientation of the gradient, the value of the corresponding pixel in the corresponding image is set */  
  
    int x, y;  
    float temp_gradient, temp_magnitude;  
    for (y = 0; y < in->height; y++) {  
  
/* ptr1 and ptr2 point to beginning of the current row in the xsobel and ysobel images respectively. ptrs point to the beginning of the current rows in the bin images */  
  
        float* ptr1 = (float*) (xsobel->imageData + y * (xsobel->widthStep));  
        float* ptr2 = (float*) (ysobel->imageData + y * (ysobel->widthStep));  
        float** ptrs = (float**) malloc(9 * sizeof(float*));  
        for (int i = 0; i < 9 ;i++){  
            ptrs[i] = (float*) (bins[i]->imageData + y * (bins->widthStep));  
        }  
  
/*For every pixel in a row gradient orientation and magnitude are calculated and corresponding values set for the bin images. */  
  
        for (x = 0; x <in->width; x++) {  
  
/* if the xsobel derivative is zero for a pixel, a small value is added to it, to avoid division by zero. atan returns values in radians, which on being converted to degrees, correspond to values between -90 and 90 degrees. 90 is added to each orientation, to shift the orientation values range from {-90-90} to {0-180}. This is just a matter of convention. {-90-90} values can also be used for the calculation. */  
  
            if (ptr1[x] == 0){  
                temp_gradient = ((atan(ptr2[x] / (ptr1[x] + 0.00001))) * (180/   PI)) + 90;  
            }  
            else{  
                temp_gradient = ((atan(ptr2[x] / ptr1[x])) * (180 / PI)) + 90;  
            }  
            temp_magnitude = sqrt((ptr1[x] * ptr1[x]) + (ptr2[x] * ptr2[x]));  
  
/*The bin image is selected according to the gradient values. The corresponding pixel value is made equal to the gradient magnitude at that pixel in the corresponding bin image */  
  
            if (temp_gradient <= 20) {  
                ptrs[0][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 40) {  
                ptrs[1][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 60) {  
                ptrs[2][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 80) {  
                ptrs[3][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 100) {  
                ptrs[4][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 120) {  
                ptrs[5][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 140) {  
                ptrs[6][x] = temp_magnitude;  
            }  
            else if (temp_gradient <= 160) {  
                ptrs[7][x] = temp_magnitude;  
            }  
            else {  
                ptrs[8][x] = temp_magnitude;  
            }  
        }  
    }  
  
    cvReleaseImage(&xsobel);  
    cvReleaseImage(&ysobel);  
  
/*Integral images for each of the bin images are calculated*/  
  
    for (int i = 0; i <9 ; i++){  
        cvIntegral(bins[i], integrals[i]);  
    }  
  
    for (int i = 0; i <9 ; i++){  
        cvReleaseImage(&bins[i]);  
    }  
  
/*The function returns an array of 9 images which consitute the integral histogram*/  
  
    return (integrals);  
  
}

如何使用上面的函数来计算9维的方向梯度直方图呢？如下：

/* The following function takes as input the rectangular cell for which the histogram of oriented gradients has to be calculated, a matrix hog_cell of dimensions 1x9 to store the bin values for the histogram, the integral histogram, and the normalization scheme to be used. No normalization is done if normalization = -1 */  
  
void calculateHOG_rect(CvRect cell, CvMat* hog_cell,  
IplImage** integrals, int normalization) {  
  
/* Calculate the bin values for each of the bin of the histogram one by one */  
  
    for (int i = 0; i < 9 ; i++){  
  
        float a =((double*)(integrals[i]->imageData + (cell.y) * (integrals->  
            widthStep)))[cell.x];  
  
        float b = ((double*) (integrals->imageData + (cell.y + cell.height) *   
            (integrals->widthStep)))[cell.x + cell.width];  
  
        float c = ((double*) (integrals->imageData + (cell.y) * (integrals-   
            >widthStep)))[cell.x + cell.width];  
  
        float d = ((double*) (integrals->imageData + (cell.y + cell.height) *   
            (integrals->widthStep)))[cell.x];  
  
        ((float*) hog_cell->data.fl) = (a + b) - (c + d);  
  
    }  
  
  
    /*Normalize the matrix*/  
    if (normalization != -1){  
        cvNormalize(hog_cell, hog_cell, 1, 0, normalization);  
    }  
  
}