C人脸识别

深碍√TFBOYSˉ_ 2024-03-17 17:51 46阅读 0赞

[FaceRecognition2: 纯C实现的一个很简单的人脸识别小项目][FaceRecognition2_ _C]

1、原始图片：

![ca2ab357910747c896df731c931999e5.bmp][]

2、灰度化下：

![548768375ff54686bcead19f09825e4f.bmp][]

3、均值滤波：

![f80255d2a8404206a7181190b05e9921.bmp][]

4、 二值图加边缘检测

![60011583d8ea4e2a9eaec4b311b12610.bmp][]

5、生成积分图（2001年，VJ人脸检测框架。Viola-Jones Objects detection framwork算法，这个对于计算某矩形区域像素个数非常有利）

![d931fcb6acb34be9aa96892058103be2.bmp][]

6、把待检测的人脸区域划分为25个，因为是一个数组，这样分别统计每个区域的像素个数：

x0: 60, y0: 100, x1: 157, y1: 200 width: 228, height: 228  
IGmap.data a4: 7979, a3: 4423, a2: 2130, a1: 1407 **result: 2833**（外层红色方框内像素个数）

x0: 60, y0: 100, x1: 79, y1: 120 width: 228, height: 228  
IGmap.data a4: 2345, a3: 2002, a2: 1624, a1: 1407 **result: 126**（第一排左边第一个小格子）

x0: 79, y0: 100, x1: 98, y1: 120 width: 228, height: 228  
IGmap.data a4: 3132, a3: 2598, a2: 2345, a1: 2002 **result: 191**（第一排左边第二个小格子）

x0: 98, y0: 100, x1: 117, y1: 120 width: 228, height: 228  
IGmap.data a4: 3790, a3: 3137, a2: 3132, a1: 2598 **result: 119**

x0: 117, y0: 100, x1: 136, y1: 120 width: 228, height: 228  
IGmap.data a4: 4551, a3: 3703, a2: 3790, a1: 3137 result: 195

x0: 136, y0: 100, x1: 155, y1: 120 width: 228, height: 228  
IGmap.data a4: 5319, a3: 4350, a2: 4551, a1: 3703 result: 121

x0: 60, y0: 120, x1: 79, y1: 140 width: 228, height: 228  
IGmap.data a4: 2549, a3: 2345, a2: 1800, a1: 1624 result: 28

x0: 79, y0: 120, x1: 98, y1: 140 width: 228, height: 228  
IGmap.data a4: 3419, a3: 3132, a2: 2549, a1: 2345 result: 83

x0: 98, y0: 120, x1: 117, y1: 140 width: 228, height: 228  
IGmap.data a4: 4106, a3: 3790, a2: 3419, a1: 3132 result: 29

x0: 117, y0: 120, x1: 136, y1: 140 width: 228, height: 228  
IGmap.data a4: 4972, a3: 4551, a2: 4106, a1: 3790 result: 105

x0: 136, y0: 120, x1: 155, y1: 140 width: 228, height: 228  
IGmap.data a4: 5757, a3: 5319, a2: 4972, a1: 4551 result: 17

x0: 60, y0: 140, x1: 79, y1: 160 width: 228, height: 228  
IGmap.data a4: 2722, a3: 2549, a2: 1913, a1: 1800 result: 60

x0: 79, y0: 140, x1: 98, y1: 160 width: 228, height: 228  
IGmap.data a4: 3688, a3: 3419, a2: 2722, a1: 2549 result: 96

x0: 98, y0: 140, x1: 117, y1: 160 width: 228, height: 228  
IGmap.data a4: 4533, a3: 4106, a2: 3688, a1: 3419 result: 158

x0: 117, y0: 140, x1: 136, y1: 160 width: 228, height: 228  
IGmap.data a4: 5482, a3: 4972, a2: 4533, a1: 4106 result: 83

x0: 136, y0: 140, x1: 155, y1: 160 width: 228, height: 228  
IGmap.data a4: 6291, a3: 5757, a2: 5482, a1: 4972 result: 24

x0: 60, y0: 160, x1: 79, y1: 180 width: 228, height: 228  
IGmap.data a4: 2874, a3: 2722, a2: 2008, a1: 1913 result: 57

x0: 79, y0: 160, x1: 98, y1: 180 width: 228, height: 228  
IGmap.data a4: 4043, a3: 3688, a2: 2874, a1: 2722 result: 203

x0: 98, y0: 160, x1: 117, y1: 180 width: 228, height: 228  
IGmap.data a4: 5052, a3: 4533, a2: 4043, a1: 3688 result: 164

x0: 117, y0: 160, x1: 136, y1: 180 width: 228, height: 228  
IGmap.data a4: 6190, a3: 5482, a2: 5052, a1: 4533 result: 189

x0: 136, y0: 160, x1: 155, y1: 180 width: 228, height: 228  
IGmap.data a4: 7121, a3: 6291, a2: 6190, a1: 5482 result: 122

x0: 60, y0: 180, x1: 79, y1: 200 width: 228, height: 228  
IGmap.data a4: 3047, a3: 2874, a2: 2130, a1: 2008 result: 51

x0: 79, y0: 180, x1: 98, y1: 200 width: 228, height: 228  
IGmap.data a4: 4405, a3: 4043, a2: 3047, a1: 2874 result: 189

x0: 98, y0: 180, x1: 117, y1: 200 width: 228, height: 228  
IGmap.data a4: 5580, a3: 5052, a2: 4405, a1: 4043 result: 166

x0: 117, y0: 180, x1: 136, y1: 200 width: 228, height: 228  
IGmap.data a4: 6851, a3: 6190, a2: 5580, a1: 5052 result: 133

x0: 136, y0: 180, x1: 155, y1: 200 width: 228, height: 228  
IGmap.data a4: 7863, a3: 7121, a2: 6851, a1: 6190 result: 81

![b8c3cdefc8a64ad1a5a81ec8de8256ac.bmp][]

运行效果图：

![552739468dfb40aa89b90f1f6b662ae9.jpeg][]

比如，这里是左边眼睛跟人中的比值(d1/d2)，和左边眼睛跟人中像素的比值(d3/d2)，正常人脸，眼睛区域比人中像素会多些 （如上图所示）

//2、两只眼睛，与人中的比例，正常来说，眼睛比人中的像素点多些
    	double d1 = (double)(Areas[0] + Areas[1] + Areas[5] + Areas[6]);        
    	double d2 = (double)(Areas[2] + Areas[7]);  
    	double d3 = (double)(Areas[3] + Areas[4] + Areas[8] + Areas[9]);
        DEBUG_PRINT_WITH_TIME("if: Step 2: %f,  %f", d1 / d2 ,  d3 / d2);
        if (d1 / d2 < 2.6 || d3 / d2 < 2.6)
        {
        	DEBUG_PRINT_WITH_TIME("1");
    		return 1;
    	}

当前还不能在图片中滑动窗口，检测窗口不断变化，这个其实也是需要测试参数的，因为图片中人脸大小是不固定的。

**代码（从这里借鉴了不少，但发现原博客有些小问题，测试了一两天）：**

#include<stdio.h>
    #include<stdlib.h>
    #include<Windows.h>
    #include<windef.h>
    #include<math.h>
    #include<string.h>
    
    #include <graphics.h>
    #include "Global.h"
    
    int FaceCount = 0;
    int angle = 0;
    
    typedef enum 
    {
        FACE_RECOGNITION_STEP_1 = 0,
        FACE_RECOGNITION_STEP_2_1,
        FACE_RECOGNITION_STEP_2_2,
        FACE_RECOGNITION_STEP_3_1,
        FACE_RECOGNITION_STEP_3_2,
        FACE_RECOGNITION_STEP_4_1,
        FACE_RECOGNITION_STEP_4_2,
        FACE_RECOGNITION_STEP_5,
        FACE_RECOGNITION_STEP_6,
        FACE_RECOGNITION_STEP_7,
        FACE_RECOGNITION_STEP_8,
        FACE_RECOGNITION_STEP_9,
        FACE_RECOGNITION_STEP_MAX,
    }FACE_RECOGNITION_STEP;
    
    // 获取文件的后缀名
    char* GetFlieExta(char* filename)
    {
        int fileLen = strlen(filename);
        int exLen = 0;
        char *fileExta = (char *)malloc(255);
        memset(fileExta, 0, 255);
    
        for (int i = fileLen-1; i > 0; i--)
            if (filename[i] == '.')
    		{
                exLen = fileLen - i;
                break;
            }
        strncpy(fileExta, filename + fileLen - exLen, exLen);
        return fileExta;
    }
    
    
    // BGRA颜色结构体
    typedef struct tagBGRA
    {
    	unsigned char blue;          // 该颜色的蓝色分量  (值范围为0-255)
    	unsigned char green;         // 该颜色的绿色分量  (值范围为0-255)
    	unsigned char red;           // 该颜色的红色分量  (值范围为0-255)
    	unsigned char transparency;  // 透明度，在bmp中是保留值，无实际效果
    }BGRA, * PBGRA;
    
    // 图像结构体
    typedef struct tagIMAGE_SELF
    {
    	unsigned int width;
    	unsigned int height;
        BGRA* data;
    }IMAGE_SELF, * PIMAGE_SELF;
    
    
    // BMP文件的处理
    
    // BMP文件头结构体
    typedef struct tagBITMAP_HEAD_INFO
    {
        /* bmp文件头的信息，有#的是重点!!*/
        // bmp文件头
        unsigned short  bfType;             // 0x424D，即BM字符串，表明是bmp格式文件
        unsigned int    bfSize;             // ###总的bmp文件大小 以字节为单位     
        unsigned short  bfReserved1;        // 保留，必须设置为0                     
        unsigned short  bfReserved2;        // 保留，必须设置为0 
        unsigned int    bfOffBits;          // ###总的bmp头部的大小（包括位图信息头），即到像素数据的偏移  
        // 位图信息头
        unsigned int    biSize;             // 位图信息头的大小
        unsigned int    biWidth;            // ###图像的宽  
        int    biHeight;           // ###图像的高  
        unsigned short  biPlanes;           // 颜色平面数，即调色盘数，恒等于1 
        unsigned short  biBitCount;         // ###图片颜色的位数,一般为32
        unsigned int    biCompression;      // 说明图象数据压缩的类型，0为不压缩
        unsigned int    biSizeImage;        // 像素数据所占大小,因为使用BI_RGB，所以设置为0
        unsigned int    biXPelsPerMeter;    // 说明水平分辨率，缺省为0
        unsigned int    biYPelsPerMeter;    // 说明垂直分辨率，缺省为0
        unsigned int    biClrUsed;          // 说明本位图实际使用调色盘的颜色索引数，0表示全部
        unsigned int    biClrImportant;     // 说明本位图重要调色盘的颜色索引数，0表示全都重要
    }BITMAP_HEAD_INFO,*PBITMAP_HEAD_INFO;
    
    // 加载BMP图片
    IMAGE_SELF *Image_bmp_load(char* filename)
    {
        IMAGE_SELF *pimageOld;
        BITMAP_HEAD_INFO bmpHeadInfo;
        FILE* fp;
    
        pimageOld = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF));
        
    	DEBUG_PRINT_WITH_TIME("filename: %s", filename);
        if ((fp = fopen(filename, "rb")) == NULL)
        {
    		printf("打开%s文件失败！\n", filename);
    		exit(0);
    	}    
        
        // 读取bmp头部
        // bmp文件头
        fread(&bmpHeadInfo.bfType, 1, sizeof(bmpHeadInfo.bfType), fp);
        fread(&bmpHeadInfo.bfSize, 1, sizeof(bmpHeadInfo.bfSize), fp);
        fread(&bmpHeadInfo.bfReserved1, 1, sizeof(bmpHeadInfo.bfReserved1), fp);
        fread(&bmpHeadInfo.bfReserved2, 1, sizeof(bmpHeadInfo.bfReserved2), fp);
        fread(&bmpHeadInfo.bfOffBits, 1, sizeof(bmpHeadInfo.bfOffBits), fp);
        // 位图信息头
        fread(&bmpHeadInfo.biSize, 1, sizeof(bmpHeadInfo.biSize), fp);
        fread(&bmpHeadInfo.biWidth, 1, sizeof(bmpHeadInfo.biWidth), fp);
        fread(&bmpHeadInfo.biHeight, 1, sizeof(bmpHeadInfo.biHeight), fp);
        fread(&bmpHeadInfo.biPlanes, 1, sizeof(bmpHeadInfo.biPlanes), fp);
        fread(&bmpHeadInfo.biBitCount, 1, sizeof(bmpHeadInfo.biBitCount), fp);
        fread(&bmpHeadInfo.biCompression, 1, sizeof(bmpHeadInfo.biCompression), fp);
        fread(&bmpHeadInfo.biSizeImage, 1, sizeof(bmpHeadInfo.biSizeImage), fp);
        fread(&bmpHeadInfo.biXPelsPerMeter, 1, sizeof(bmpHeadInfo.biXPelsPerMeter), fp);
        fread(&bmpHeadInfo.biYPelsPerMeter, 1, sizeof(bmpHeadInfo.biYPelsPerMeter), fp);
        fread(&bmpHeadInfo.biClrUsed, 1, sizeof(bmpHeadInfo.biClrUsed), fp);
        fread(&bmpHeadInfo.biClrImportant, 1, sizeof(bmpHeadInfo.biClrImportant), fp);
    
    	//DEBUG_PRINT_WITH_TIME("bfType: %d, bfSize: %d, bfOffBits: %d", bmpHeadInfo.bfType, bmpHeadInfo.bfSize, bmpHeadInfo.bfOffBits)
    	//DEBUG_PRINT_WITH_TIME("bfReserved1: %d, bfReserved2: %d", bmpHeadInfo.bfReserved1, bmpHeadInfo.bfReserved2)
    
    	DEBUG_PRINT_WITH_TIME("biWidth: %d, Height: %d", bmpHeadInfo.biWidth, bmpHeadInfo.biHeight)
    
        if (bmpHeadInfo.biHeight < 0)
        {
            DEBUG_PRINT_WITH_TIME("BMP Height is negative...")
            exit(0);
        }
    
        // 读取bmp位图数据
        BGRA* bgra = (BGRA*)malloc(sizeof(BGRA) * (bmpHeadInfo.biWidth * bmpHeadInfo.biHeight));
        fseek(fp, bmpHeadInfo.bfOffBits, SEEK_SET);
    
        if (bmpHeadInfo.biBitCount == 32)
        {
           for (unsigned int i = 0; i < bmpHeadInfo.biWidth * bmpHeadInfo.biHeight; i++)
                fread(&bgra[i], 1, sizeof(BGRA), fp);
        }
        else if (bmpHeadInfo.biBitCount == 24)
        {
    		// 计算每行补几个字节零
            int k = 4 * (3 * bmpHeadInfo.biWidth / 4 + 1) - 3 * bmpHeadInfo.biWidth;
            for (unsigned int i = 0; i < bmpHeadInfo.biWidth * bmpHeadInfo.biHeight; i++)
            {
                if (k != 4 && (ftell(fp)- 54 + k ) % (3 * bmpHeadInfo.biWidth + k)==0)
                    fseek(fp, ftell(fp) + k, SEEK_SET);
    
                fread(&bgra[i].blue, 1, sizeof(unsigned char), fp);
                fread(&bgra[i].green, 1, sizeof(unsigned char), fp);
                fread(&bgra[i].red, 1, sizeof(unsigned char), fp);
                bgra[i].transparency = (unsigned char)0xFF;
            }
        }
    
    
    
        pimageOld->data = bgra;
        pimageOld->width = bmpHeadInfo.biWidth;
        pimageOld->height = bmpHeadInfo.biHeight;
    
        fclose(fp);
        return pimageOld;
    }
    
    // 保存BMP图片
    void Image_bmp_save(char* filename, IMAGE_SELF *imageOld)
    {
        FILE* fp = fopen(filename, "wb");
    
        unsigned short  bfType = 0x4D42;                // 0x424D，即BM字符串，表明是bmp格式文件
        unsigned int    bfSize = imageOld->width * imageOld->height * 4 + 54;  // ###总的bmp文件大小 以字节为单位     
        unsigned short  bfReserved1 = 0;                // 保留，必须设置为0                     
        unsigned short  bfReserved2 = 0;                // 保留，必须设置为0 
        unsigned int    bfOffBits = 54;                 // ###总的bmp头部的大小（包括位图信息头），即到像素数据的偏移  
        unsigned int    biSize = 40;                    // 位图信息头的大小
        unsigned int    biWidth = imageOld->width;                 // ###图像的宽  
        unsigned int    biHeight = imageOld->height;                // ###图像的高  
        unsigned short  biPlanes = 1;                   // 颜色平面数，即调色盘数，恒等于1 
        unsigned short  biBitCount = 32;                // ###图片颜色的位数,一般为32
        unsigned int    biCompression = 0;              // 说明图象数据压缩的类型，0为不压缩
        unsigned int    biSizeImage = 0;                // 像素数据所占大小,因为使用BI_RGB，所以设置为0
        unsigned int    biXPelsPerMeter = 0;            // 说明水平分辨率，缺省为0
        unsigned int    biYPelsPerMeter = 0;            // 说明垂直分辨率，缺省为0
        unsigned int    biClrUsed = 0;                  // 说明本位图实际使用调色盘的颜色索引数，0表示全部
        unsigned int    biClrImportant = 0;             // 说明本位图重要调色盘的颜色索引数，0表示全都重要
    
        fwrite(&bfType, 2, 1, fp);
        fwrite(&bfSize, 4, 1, fp);
        fwrite(&bfReserved1, 2, 1, fp);
        fwrite(&bfReserved2, 2, 1, fp);
        fwrite(&bfOffBits, 4, 1, fp);
        fwrite(&biSize, 4, 1, fp);
        fwrite(&biWidth, 4, 1, fp);
        fwrite(&biHeight, 4, 1, fp);
        fwrite(&biPlanes, 2, 1, fp);
        fwrite(&biBitCount, 2, 1, fp);
        fwrite(&biCompression, 4, 1, fp);
        fwrite(&biSizeImage, 4, 1, fp);
        fwrite(&biXPelsPerMeter, 4, 1, fp);
        fwrite(&biYPelsPerMeter, 4, 1, fp);
        fwrite(&biClrUsed, 4, 1, fp);
        fwrite(&biClrImportant, 4, 1, fp);
    
        fwrite(imageOld->data, sizeof(BGRA) * imageOld->width * imageOld->height, 1, fp);
    
        fclose(fp);
    }
    
    
    // 加载图片
    IMAGE_SELF *Image_load(char* filename)
    {
        IMAGE_SELF *im;
        //char* fileEx= GetFlieExta(filename);
    	//DEBUG_PRINT_WITH_TIME("fileEx: %s", fileEx);
        //if (strcmp(fileEx, ".bmp") == 0)
            im = Image_bmp_load(filename);
    
        return im;
    }
    
    char OutputFileCount = '1';
    
    // 保存图片
    void Image_save(char* filename, IMAGE_SELF *imageOld)
    {
        char* fileEx = GetFlieExta(filename);
    
        filename[strlen(filename) - 5] = OutputFileCount++;
    
        if (strcmp(fileEx, ".bmp") == 0)
            Image_bmp_save(filename, imageOld);
    }
    
    // 释放图像结构体
    void Image_free(IMAGE_SELF *imageOld)
    {
        free(imageOld->data);
        free(imageOld);
    }
    
    #define GRAY_MODE_WEIGHT 1           // 加权法(推荐使用)
    
    // 彩色图转灰度图
    IMAGE_SELF *Transform_color_grayscale(IMAGE_SELF *imageOld, int grayscale_mode)
    {
        int color = 0;
        
        IMAGE_SELF *imageNew;
    	imageNew = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF));
    	
        imageNew->width = imageOld->width;
        imageNew->height = imageOld->height;
    	imageNew->data = (BGRA*)malloc(sizeof(BGRA) * imageOld->width * imageOld->height);
    	
        switch (grayscale_mode)
        {
    	    case GRAY_MODE_WEIGHT:
    	    {
    	        for (unsigned int i = 0; i < imageOld->width * imageOld->height; i++)
    	        {
    	            color = (imageOld->data[i].blue * 114 + imageOld->data[i].green * 587 + imageOld->data[i].red * 299) / 1000;
    	            imageNew->data[i].blue = color;
    	            imageNew->data[i].green = color;
    	            imageNew->data[i].red = color;
    	        }
    	        break;
    	    }
    
    	    default: DEBUG_PRINT_WITH_TIME("error:  switch default branch....");
        }
    	return imageNew;
    }
    
    // 二值图(自适应阈值法，areaSize=25较合适，当图片线条多且密时，不推荐使用)
    IMAGE_SELF *Transform_color_BW_Adaptive(IMAGE_SELF *imageOld, int areaSize)
    {
    	IMAGE_SELF *imageNew;
    	imageNew = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF) );	
    	
        imageNew->width = imageOld->width;
        imageNew->height = imageOld->height;
    	
        // areaSize为区域的大小，区域越大，效果图的细节越好，areaSize=25较合适
        BGRA* bgra = (BGRA*)malloc(sizeof(BGRA) * imageOld->width * imageOld->height);
        int* p = (int*)malloc(sizeof(int) * areaSize); // p->position 位置坐标
        int k = (int)(sqrt((double)areaSize)) / 2;  // 重合区域边长的一半
    
        for (unsigned int i = 0; i < imageOld->width * imageOld->height; i++)
        {
            // 计算与卷积和对应重合区域的坐标
            int t = 0; // 记录p的下标
            for (int n = k; n >= -k; n--)
                for (int m = -k; m <= k; m++)
                {
                    p[t] = ((i % imageOld->width) + m) + (i / imageOld->width + n) * imageOld->width;
                    t++;
                }
    
            // 判断是否越界
            for (int j = 0; j < areaSize; j++)
                if (p[j] < 0 || p[j] >= imageOld->width * imageOld->height)
                    p[j] = i;
    
            unsigned int color = 0;
            for (int j = 0; j < areaSize; j++)
                color += imageOld->data[p[j]].blue;
            color /= areaSize;
    
            if (imageOld->data[i].blue >= color)
                bgra[i].blue = 255;
            else
                bgra[i].blue = 0;
    
            bgra[i].green = bgra[i].blue;
            bgra[i].red = bgra[i].blue;
        }
    
        free(p);
        imageNew->data = bgra;
        return imageNew;
    }
    
    // 判断像素值的范围
    unsigned char Tool_RBG(int BRRA)
    {
        if (BRRA > 255)
            return (unsigned char)255;
        else if (BRRA < 0)
            return (unsigned char)0;
        else
            return (unsigned char)BRRA;
    }
    
    // 卷积操作（自定义）
    IMAGE_SELF *Kernels_use_DIY(IMAGE_SELF *imageOld, double* kernels, int areaSize, double modulus)
    {
    	IMAGE_SELF *imageNew;
    	imageNew = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF) );	
        imageNew->width = imageOld->width;
        imageNew->height = imageOld->height;
    	imageNew->data = (BGRA*)malloc(sizeof(BGRA) * imageOld->width * imageOld->height);	
    	memcpy(imageNew->data, imageOld->data, sizeof(BGRA) * imageOld->width * imageOld->height);
    	
    	// kernels卷积核
    	// areaSize区域的大小
    	// modulus最后乘的系数
    	
        BGRA* bgra = (BGRA*)malloc(sizeof(BGRA) * imageOld->width * imageOld->height);
        int* p = (int*)malloc(sizeof(int) * areaSize); // p->position 位置坐标
        int k = (int)(sqrt((double)areaSize)) / 2;  // 重合区域边长的一半
    
        for (unsigned int i = 0; i < imageOld->width * imageOld->height; i++)
        {
            // 计算与卷积和对应重合区域的坐标
            int t = 0; // 记录p的下标
            for(int n = k; n >= -k; n--)
                for (int m = -k; m <= k; m++)
                    p[t] = ((i % imageOld->width) + m) + (i / imageOld->width + n) * imageOld->width, t++;
                    
            // 判断是否越界
            for (int j = 0; j < areaSize; j++) 
                if (p[j] < 0 || p[j] >= imageOld->width * imageOld->height)
                    p[j] = i;
    
    		// 相乘相加
            int blue = 0, green = 0, red = 0;
            for (int j = 0; j < areaSize; j++)
            {
                blue += imageOld->data[p[j]].blue * kernels[j];
                green += imageOld->data[p[j]].green * kernels[j];
                red += imageOld->data[p[j]].red * kernels[j];
            }
            
            bgra[i].blue = Tool_RBG(blue * modulus);
            bgra[i].green = Tool_RBG(green * modulus);
            bgra[i].red = Tool_RBG(red * modulus);
        }
    
        free(p);
        imageNew->data = bgra;
        return imageNew;
    }
    
    // 均值滤波卷积核
    double KERNELS_Wave_Average[25] =
    {
      1, 1, 1, 1, 1,
      1, 1, 1, 1, 1,
      1, 1, 1, 1, 1,
      1, 1, 1, 1, 1,
      1, 1, 1, 1, 1
    };
    
    // 均值滤波
    IMAGE_SELF *Wavefiltering_Average(IMAGE_SELF *imageOld)
    {
        return Kernels_use_DIY(imageOld, KERNELS_Wave_Average, 25, 1.0 / 25);
    }
    
    
    // 积分图结构体
    typedef struct tagIGIMAGE_SELF
    {
        unsigned int width;
        unsigned int height;
        unsigned int *data;
    }IGIMAGE_SELF, *PIGIMAGE_SELF;
    
    
    typedef struct tagEXPECTANT_ITEM
    {
        float ExpectantValue; //期望值
        int Type; //1: 大于，2：小于
        char Note[100]; //注释
    }EXPECTANT_ITEM;
    
    EXPECTANT_ITEM gExpectants[FACE_RECOGNITION_STEP_MAX];
    
    
    // 图像的任意角度的旋转
    IMAGE_SELF *Transform_shape_whirl(IMAGE_SELF *imageOld, float angle)
    {
        // 转角度换成弧度
        angle = PI * angle / 180;
        
        IMAGE_SELF *imageNew;
    	imageNew = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF) );	
        //imageNew->width = imageOld->width;
        //imageNew->height = imageOld->height;
    	//imageNew->data = (BGRA*)malloc(sizeof(BGRA) * imageOld->width * imageOld->height);	
    
        float cosnum = (float)cos(angle);   
        float sinnum = (float)sin(angle);
    
        // 计算原图的四个角的坐标
        int fx2 = imageOld->width - 1;
        int fy2 = 0;
        int fx3 = 0;
        int fy3 = imageOld->height - 1;
        int fx4 = imageOld->width - 1;
        int fy4 = imageOld->height - 1;
    
        // 计算旋转后的图像四个角的坐标
        int nx1 = 0;
        int ny1 = 0;
        int nx2 = (int)(fx2 * cosnum + fy2 * sinnum);
        int ny2 = (int)(fy2 * cosnum - fx2 * sinnum);
        int nx3 = (int)(fx3 * cosnum + fy3 * sinnum);
        int ny3 = (int)(fy3 * cosnum - fx3 * sinnum);
        int nx4 = (int)(fx4 * cosnum + fy4 * sinnum);
        int ny4 = (int)(fy4 * cosnum - fx4 * sinnum);
    
        // 计算旋转后的图像的宽和高
        unsigned int width = abs(max(max(nx1, nx2), max(nx3, nx4))) + abs(min(min(nx1, nx2), min(nx3, nx4))) + 1;
        unsigned int hight = abs(max(max(ny1, ny2), max(ny3, ny4))) + abs(min(min(ny1, ny2), min(ny3, ny4))) + 1;
    
        // 计算旋转后的图像到第一象限的位置偏移
        int bx = abs(min(min(nx1, nx2), min(nx3, nx4)));
        int by = abs(min(min(ny2, ny3), ny4));
    
        // 申请并初始化内存空间
        BGRA* bgra = (BGRA*)calloc(width * hight, sizeof(BGRA));
        
        for (unsigned int i = 0; i < imageOld->width * imageOld->height; i++)
        {
            // 注意(int)放的位置，不能随便移动,因为y可能为负的小数 
            unsigned int k = ((i % imageOld->width) * cosnum + (i / imageOld->width) * sinnum + bx) + (int)((i / imageOld->width) * cosnum - (i % imageOld->width) * sinnum + by) * width;
    
            // 判断是否越界
            if (k >= width * hight)
                k = width * hight - 1;
    
            bgra[k].blue = imageOld->data[i].blue;
            bgra[k].green = imageOld->data[i].green;
            bgra[k].red = imageOld->data[i].red;
            bgra[k].transparency = 255;
        }
    
        // 用邻近的像素填充空白区域
        for (unsigned int i = 0; i < width * hight; i++)
        {
            if (bgra[i].transparency != 255)
            {
                bgra[i].blue = 255;
                bgra[i].green = 255;
                bgra[i].red = 255;
                bgra[i].transparency = 255;
            }
        }
    
        //free(imageOld.data);
        imageNew->data = bgra;
        imageNew->width = width;
        imageNew->height = hight;
        return imageNew;
    }
    
    
    // 获得积分图（在此之前要保证图片是“白底黑字”）
    IGIMAGE_SELF *IntegralImage_get(IMAGE_SELF *imageOld)
    {
        IGIMAGE_SELF *IGmap;
    
    	IGmap = (IGIMAGE_SELF *)malloc(sizeof(IGIMAGE_SELF));
    
        
        unsigned int* array = (unsigned int *)malloc(sizeof(unsigned int) * imageOld->width * imageOld->height);
        memset(array, 0, sizeof(int) * imageOld->width * imageOld->height);
    
        int k = 0; // 用于统计每一行的像素个数
        
        for(int height = imageOld->height; height > 0; height--)
    	{
    		k = 0;
    		for(int width = 0; width < imageOld->width; width++)
    		{
    			int temp = imageOld->data[(height - 1) * imageOld->width + width].blue;
    			if(temp == 0)
    			{
    				k++;
    			}
    			if (temp == 0)
    			{
    				//printf("y:");
    			}
    			else
    			{
    				//printf("n:");
    			}
    			
    			int heightTemp = imageOld->height - height;
    			if (height == imageOld->height)
    			{
    				array[width] = k;
    			}
    			else
    			{
    				array[heightTemp * imageOld->width + width] =  array[(heightTemp - 1) * imageOld->width + width] + k;
    				//printf("%3d ", array[heightTemp * imageOld.width + width]);
    			}
    		}
    		//printf("\n");
    		//Sleep(1000);
    		//pause();
    		//DEBUG_PRINT_WITH_TIME("height: %d, k: %d", height, k);
    	}
    
        IGmap->data = array;
        IGmap->width = imageOld->width;
        IGmap->height = imageOld->height;
        return IGmap;
    }
    
    // 计算积分区域像素个数
    //int IntegralImage_count(IGIMAGE_SELF IGmap, int x0, int y0, int x1, int y1)
    long IntegralImage_count(IGIMAGE_SELF *IGmap, int x0, int y0, int x1, int y1)
    {
        long a1, a2, a3, a4;
        //int leftBottom = x0 + y1 *IGmap.width;
        //int rightTop = x1 + y0 *IGmap.width;
        
        if(x0 > IGmap->width || x1 > IGmap->width || y1 > IGmap->height || y0 > IGmap->height)
    	{
    		DEBUG_PRINT_WITH_TIME("x0: %d, y0: %d, x1: %d, y1: %d    width: %d, height: %d", x0, y0, x1, y1, IGmap->width, IGmap->height)
    		return -1;
    	}
        
    	//DEBUG_PRINT_WITH_TIME("x0: %ld, y0: %ld, x1: %ld, y1: %ld    width: %d, height: %d", x0, y0, x1, y1, IGmap.width, IGmap.height)
        
        a1 = y0 * IGmap->width + x0;
        a2 = y1 * IGmap->width + x0;
        a3 = y0 * IGmap->width + x1;
        a4 = y1 * IGmap->width + x1;
    
    	//DEBUG_PRINT_WITH_TIME("a4: %u, a3: %u, a2: %u, a1: %u", a4, a3, a2, a1)
        //  判断是否越界
        if (a1 < 0)
            a1 = 0;
        if (a2 < 0)
            a2 = 0;
        if (a3 < 0)
            a3 = 0;
        if (a3 > IGmap->width * IGmap->height - 1)
            a3 = a4;
    
    	long result = IGmap->data[a4] + IGmap->data[a1] - IGmap->data[a3]  - IGmap->data[a2];
    	//DEBUG_PRINT_WITH_TIME("IGmap.data a4: %u, a3: %u, a2: %u, a1: %u result: %u\n", IGmap.data[a4], IGmap.data[a3], IGmap.data[a2], IGmap.data[a1], result)
    		
        // 计算区域中的像素数
        return  result;
    }
    
    // 释放积分图结构体
    void IntegralImage_free(IGIMAGE_SELF *IGimage)
    {
        free(IGimage->data);
    	free(IGimage);
    }
    
    // 单分支决策树分类器
    double Classifier_decisionStump(IGIMAGE_SELF *IGmap, int x0, int y0, int x1, int y1, float *parameters)
    {   
        //DEBUG_PRINT_WITH_TIME("x0: %d, y0: %d, x1: %d, y1: %d\n", x0, y0, x1, y1);
        int areaW = abs(x0-x1);
        int areaH = abs(y0-y1);
    
    	int xStep = abs(x0-x1)/5;
    	int yStep = abs(y0-y1)/5;
    	
    	long Areas[25] = {0};
    	double ReturnFlag = 0;
    	
    	for(int j = 0; j < 5; j++)
    	{
    		for(int i = 0; i < 5; i++)
    		{
    			Areas[j * 5 + i] = IntegralImage_count(IGmap, x0 + i * xStep, y0 + yStep * j, x0 + (i + 1) * xStep, y0 + yStep * (j + 1));
    			//DEBUG_PRINT_WITH_TIME("j: %d, i: %d, num: %d\n", j, i, num);
    		}
    	}
    
    	for(int i=0;i<25;i++)
    	{
    		//printf("%d: %d, ", i, Areas[i]);
    	}
    	
    	// 计算25个区域的像素个数
    	int w_all = IntegralImage_count(IGmap, x0, y0, x1, y1);
    	
    	//DEBUG_PRINT_WITH_TIME("if: Step 1 计算25个区域的像素个数占面积像素比( > 0.19) : %f", (double)w_all / (areaW * areaH));
    	parameters[FACE_RECOGNITION_STEP_1] = (float)w_all / (areaW * areaH);
        if ((double)w_all / (areaW * areaH) < gExpectants[FACE_RECOGNITION_STEP_1].ExpectantValue)
        {
        	//DEBUG_PRINT_WITH_TIME("if return");
    		ReturnFlag = FACE_RECOGNITION_STEP_1;
    		return ReturnFlag;
    	}
    
    	//2、两只眼睛，与人中的比例，正常来说，眼睛比人中的像素点多些
    	float d1 = (float)(Areas[0] + Areas[1] + Areas[5] + Areas[6]);        
    	float d2 = (float)(Areas[2] + Areas[7]);  
    	float d3 = (float)(Areas[3] + Areas[4] + Areas[8] + Areas[9]);
        //DEBUG_PRINT_WITH_TIME("if: Step 2 两只眼睛，与人中的比例，正常来说，眼睛比人中的像素点多些( > 2.6) : %f,  %f", d1 / d2 ,  d3 / d2);
        parameters[FACE_RECOGNITION_STEP_2_1] = d1 / d2;
        parameters[FACE_RECOGNITION_STEP_2_2] = d1 / d2;
        float temp = gExpectants[FACE_RECOGNITION_STEP_2_1].ExpectantValue;
    	if (d1 / d2 < temp || d3 / d2 < temp)
        {
        	//DEBUG_PRINT_WITH_TIME("if return");
    		ReturnFlag = FACE_RECOGNITION_STEP_2_1;
    		return ReturnFlag;
    	}
    	
    	//3、鼻子的像素正常比鼻子两边像素多些
    	d1 = (double)(Areas[12] + Areas[17]);
    	d2 = (double)(Areas[11] + Areas[16]);
    	float d4 = (double)(Areas[13] + Areas[18]);
        //DEBUG_PRINT_WITH_TIME("if: Step 3 鼻子的像素正常比鼻子两边像素多些( > 1): %f,  %f",  d1 / d2 , d3 / d4);
        parameters[FACE_RECOGNITION_STEP_3_1] = d1 / d2;
        parameters[FACE_RECOGNITION_STEP_3_2] = d3 / d4;
    
        temp = gExpectants[FACE_RECOGNITION_STEP_3_1].ExpectantValue;
    	if (d1 / d2 < temp || d1 / d4 < temp)
        {
        	//DEBUG_PRINT_WITH_TIME("if return");
    		ReturnFlag = FACE_RECOGNITION_STEP_3_1;
    		return ReturnFlag;
    	}
    	
    	//4、眼睛的像素比眼睛下边的脸像素少些，两边都是，因为考虑到还有胡子
    	d1 = (double)(Areas[0] + Areas[1] + Areas[5] + Areas[6]);
    	d2 = (double)(Areas[10] + Areas[11] + Areas[15]);
    	d3 = (double)(Areas[3] + Areas[4] + Areas[8] + Areas[9]);
    	d4 = (double)(Areas[13] + Areas[14] + Areas[19]);   
        //DEBUG_PRINT_WITH_TIME("if: Step 4 眼睛的像素比眼睛下边的脸像素少些，两边都是，因为考虑到还有胡子( > 1.3) : %f,  %f",  d1 / d2 , d3 / d4);
        parameters[FACE_RECOGNITION_STEP_4_1] = d1 / d2;
        parameters[FACE_RECOGNITION_STEP_4_2] = d3 / d4;
        temp = gExpectants[FACE_RECOGNITION_STEP_4_1].ExpectantValue;
        if (d1 / d2 < temp || d3 / d4 < temp)
        {
        	//DEBUG_PRINT_WITH_TIME("if return");
    		ReturnFlag = FACE_RECOGNITION_STEP_4_1;
    		return ReturnFlag;
    	}
    
        d1 = 0;
        d2 = 0;
        for (int i = 0; i < 10; i++)
        {
            d1 += Areas[i];
            d2 += Areas[15 + i];
        }
    
    	//5、上边脸跟嘴和下巴像素的比值
    	//d1 = (double)(Areas[0] + Areas[1] + Areas[2] + Areas[3] + Areas[4] + Areas[5] + Areas[6] + Areas[7] + Areas[8] + Areas[9]);
    	//d2 = (double)(Areas[15] + Areas[16] + Areas[17] + Areas[18] + Areas[19] + Areas[20] + Areas[21] + Areas[22] + Areas[23] + Areas[24]);
        //DEBUG_PRINT_WITH_TIME("if: Step 5 上边脸跟嘴和下巴像素的比值( > 2): %f", d1 / d2);
        parameters[FACE_RECOGNITION_STEP_5] = d1 / d2;
    
        if ( d1 / d2 > gExpectants[FACE_RECOGNITION_STEP_5].ExpectantValue)
        {
            //DEBUG_PRINT_WITH_TIME("if return");
            ReturnFlag = FACE_RECOGNITION_STEP_5;
            return ReturnFlag;
        }
    
    	//6、眼睛和嘴巴所占的像素比值不能太小
    	d1 = (double)(Areas[0] + Areas[1] + Areas[3] + Areas[4] + Areas[5] + Areas[6] + Areas[8] + Areas[9] 
    				+ Areas[12] + Areas[16] + Areas[17] + Areas[18] + Areas[22]);
        //DEBUG_PRINT_WITH_TIME("if: Step 6 眼睛和嘴巴所占的像素比值不能太小( > 0.5) : %f", d1 / w_all);
        parameters[FACE_RECOGNITION_STEP_6] = d1 / d2;
    	if (d1/ w_all < gExpectants[FACE_RECOGNITION_STEP_6].ExpectantValue)
        {
            //DEBUG_PRINT_WITH_TIME("if return");
            ReturnFlag = FACE_RECOGNITION_STEP_6;
            return ReturnFlag;
        }
        
    	//7、脸左边跟脸右边的比值不能差太多
    	d1 = (double)(Areas[0] + Areas[1] + Areas[5] + Areas[6] + Areas[10] + Areas[11]  + Areas[15] + Areas[16]  + Areas[20] + Areas[21]);
    	d2 = (double)(Areas[3] + Areas[4] + Areas[8] + Areas[9] + Areas[13] + Areas[14] + Areas[18] + Areas[19] + Areas[23] + Areas[24]);
        double PCT_1 = (double)min(d1, d2)/ max(d1, d2);
        parameters[FACE_RECOGNITION_STEP_7] = PCT_1;
        PCT_1 = exp(-3.125 * (PCT_1 - 1) * (PCT_1 - 1)) * 100;
    
    	//8、两只眼睛的比值不能差太多
    	d1 = (double)(Areas[0] + Areas[1] + Areas[5] + Areas[6]);
    	d2 = (double)(Areas[3] + Areas[4] + Areas[8] + Areas[9]);
        double PCT_2 = (double)min(d1, d2) / max(d1, d2);
        parameters[FACE_RECOGNITION_STEP_8] = PCT_2;
        PCT_2 = exp(-3.125 * (PCT_2 - 1) * (PCT_2 - 1)) * 100;
    
    	//9、两腮的比值不能差太多
    	d1 = (double)(Areas[15] + Areas[20]);
    	d2 = (double)(Areas[19] + Areas[24]);
        double PCT_3 = (double)min(d1, d2) / max(d1, d2);
        parameters[FACE_RECOGNITION_STEP_9] = PCT_3;
        PCT_3 = exp(-3.125 * (PCT_3 - 1) * (PCT_3 - 1)) * 100;
    
        // 计算总的概率
        double PCT_all = (PCT_1 + PCT_2 + PCT_3) / 3;
    
    	//DEBUG_PRINT_WITH_TIME("PCT_all: %f, PCT_1: %f, PCT_2: %f, PCT_3: %f", PCT_all, PCT_1, PCT_2, PCT_3)
            
        // 1、判断是否为人脸，整个区域有的像素个数占整个区域面积的比例
    	if (ReturnFlag != 0)
    	{
    	    return ReturnFlag;
    	}
    	else if (PCT_all > 60)
    	{
    		return PCT_all;
    	}
    	else 
    	{
    		return -1;
    	}    
    }
    
    // 人脸数据结构体
    typedef struct tagFACE_RESULT
    {
        int x0;
        int y0;
        int x1;
        int y1;
        float parameters[FACE_RECOGNITION_STEP_MAX];
        int angle; //旋转角度
        double confidence;
    }FACE_RESULT;
    
    int GraphicsInitial(IMAGE_SELF *imageOld)
    {    
    	setinitmode(0);
    	initgraph(imageOld->width * 2, imageOld->height * 2);
    	
    	setcolor(RED);
    	
    	setlinewidth(2);
    }
    
    //期望值初始化，包含：值是多少，阈值是多少，是大于还是小于，期望值说明
    int ExpectantsInitial()
    {
        gExpectants[FACE_RECOGNITION_STEP_1].ExpectantValue = 0.19;
        gExpectants[FACE_RECOGNITION_STEP_1].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_1].Note, "Step 1 计算25个区域的像素个数占面积像素比期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_2_1].ExpectantValue = 2.6;
        gExpectants[FACE_RECOGNITION_STEP_2_1].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_2_1].Note, "Step 2_1 两只眼睛，与人中的比例，正常来说，眼睛比人中的像素点多些期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_2_2].ExpectantValue = 2.6;
        gExpectants[FACE_RECOGNITION_STEP_2_2].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_2_2].Note, "Step 2_2 两只眼睛，与人中的比例，正常来说，眼睛比人中的像素点多些期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_3_1].ExpectantValue = 1;
        gExpectants[FACE_RECOGNITION_STEP_3_1].Type = 1;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_3_1].Note, "Step 3_1 鼻子的像素正常比鼻子两边像素多些期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_3_2].ExpectantValue = 1;
        gExpectants[FACE_RECOGNITION_STEP_3_2].Type = 1;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_3_2].Note, "Step 3_2 鼻子的像素正常比鼻子两边像素多些期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_4_1].ExpectantValue = 1.3;
        gExpectants[FACE_RECOGNITION_STEP_4_1].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_4_1].Note, "Step 4_1 眼睛的像素比眼睛下边的脸像素少些，两边都是，因为考虑到还有胡子期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_4_2].ExpectantValue = 1.3;
        gExpectants[FACE_RECOGNITION_STEP_4_2].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_4_2].Note, "Step 4_2 眼睛的像素比眼睛下边的脸像素少些，两边都是，因为考虑到还有胡子期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_5].ExpectantValue = 2;
        gExpectants[FACE_RECOGNITION_STEP_5].Type = 1;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_5].Note, "Step 5 上边脸跟嘴和下巴像素的比值期望 < ");
    
        gExpectants[FACE_RECOGNITION_STEP_6].ExpectantValue = 0.6;
        gExpectants[FACE_RECOGNITION_STEP_6].Type = 2;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_6].Note, "Step 6 眼睛和嘴巴所占整个区域总的像素比值不能太小期望 > ");
    
        gExpectants[FACE_RECOGNITION_STEP_7].ExpectantValue = 0;
        gExpectants[FACE_RECOGNITION_STEP_7].Type = 0;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_7].Note, "Step 7 脸左边跟脸右边的比值不能差太多 ");
    
        gExpectants[FACE_RECOGNITION_STEP_8].ExpectantValue = 0;
        gExpectants[FACE_RECOGNITION_STEP_8].Type = 0;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_8].Note, "Step 8 两只眼睛的比值不能差太多 ");
    
        gExpectants[FACE_RECOGNITION_STEP_9].ExpectantValue = 0;
        gExpectants[FACE_RECOGNITION_STEP_9].Type = 0;
        strcpy(gExpectants[FACE_RECOGNITION_STEP_9].Note, "Step 9 两腮的比值不能差太多 ");
    
    	return 0;
    }
    
    //手动调试模式，用鼠标点击，这样图片太大可以使用这种方法，比较快速测试哪些参数不太合理
    int ManualMode(IMAGE_SELF imageOld, IGIMAGE_SELF *IGmap)
    {    
    	int x0 = 0;
    	int y0 = 0;
    	int x1 = 0;
    	int y1 = 0;
        
    	int DefaultFaceWidth = 97;
    	int DefaultFaceHeight = 100;
    	
    	setinitmode(0);
    	initgraph(imageOld.width, imageOld.height);
    	
    	setcolor(RED);
    	
    	setlinewidth(2);
    	
        //在画板画出图像，这里其实有优化的空间，当前偷懒整个画板更新
        //实际上不需要，只需要更新上次画的红色格子区域就行，当前对性能有点损耗
        for(unsigned int i = imageOld.height - 1; i > 0 ; i--)
        {
            for(unsigned int j = 0; j < imageOld.width; j++)
            {
                unsigned int point = (imageOld.height - i) * imageOld.width + j; 
                putpixel(j, i, EGERGB(imageOld.data[point].red, 
                                       imageOld.data[point].green, 
                                       imageOld.data[point].blue));
            }
        }
        
        while(1)
    	{
            int  ret = mousemsg();
            if (! ret)
                continue;
            
            mouse_msg m = getmouse();
            if (!m.is_down() ||  !m.is_left())
                continue;
        					    
    		x0 = m.x;   
    		y0 = m.y; 
    		x1 = x0 + DefaultFaceWidth;
    		y1 = y0 + DefaultFaceHeight;
    	    //DEBUG_PRINT_WITH_TIME("x0: %d, y0: %d, x1: %d, y1: %d", x0, y0, x1, y1);
    
            //在画板画出图像，这里其实有优化的空间，当前偷懒整个画板更新
            //实际上不需要，只需要更新上次画的红色格子区域就行，当前对性能有点损耗
            for(unsigned int i = imageOld.height - y0; i > imageOld.height - y1 ; i--)
            {
                for(unsigned int j = x0 - 1; j < x0 + 1; j++)
                {
                    unsigned int point = (imageOld.height - i) * imageOld.width + j; 
                    putpixel(j, i, EGERGB(imageOld.data[point].red, 
                                           imageOld.data[point].green, 
                                           imageOld.data[point].blue));
                }
            }
            
            //画出当前在运行的方框
            rectangle(x0, y0, x1, y1);
            
            //在红色方框里边画5*5个小方框，为了大概看到每个方框像素点个数
            int xStep = abs(x0-x1)/5;
            int yStep = abs(y0-y1)/5;
            
            for(int j = 1; j < 5; j++)
            {
                line(x0 + xStep * j, y0, x0 + xStep * j, y1 );
                line(x0, y0 + yStep * j, x1, y0 + yStep * j );
            }
    		 //记录找到的脸对应的参数，用于未找到正确人脸，查看是哪些参数出了问题，可用于优化
            float parameters[FACE_RECOGNITION_STEP_MAX] = {0};      
            double confidenceTemp = Classifier_decisionStump(IGmap, x0, y0, x1, y1, parameters);
            //if (confidenceTemp > 60.2f)
            DEBUG_PRINT_WITH_TIME("confidenceTemp: %lf, x0: %d, y0: %d, x1: %d, y1: %d\n", confidenceTemp, x0, y0, x1, y1);
    
            for (int i = 0; i < FACE_RECOGNITION_STEP_MAX; i++)
            {
                DEBUG_PRINT_WITH_TIME("%s%f，实际: %f", gExpectants[i].Note, gExpectants[i].ExpectantValue, parameters[i]);
            } 
            DEBUG_PRINT_WITH_TIME("\n");
        
            Sleep(10);
        }
    
        return 0;
    
       
    
    }
    
    //滑动窗口区域（训练用）
    int MoveWindowArea(IMAGE_SELF *imageOld, IGIMAGE_SELF *IGmap, FACE_RESULT *FoundFaces)
    {    	
    	int FaceWidth = 97;
    	int FaceHeight = 100;
    	int MoveStepSize = 8;
    	
    	int x0 = 0;
    	int y0 = 0;
    	for(int i = 0; i * MoveStepSize < imageOld->width - FaceWidth; i++) //height
    	{
    	    x0 += MoveStepSize;
    	    y0 = 0;
    		for(int j = 0 ; j * MoveStepSize < imageOld->height - FaceHeight; j++)
    		{
    			y0 +=  MoveStepSize;
    			int x1 = x0 + 97;
    			int y1 = y0 + 100;
    
                DEBUG_PRINT_WITH_TIME();
                
    			//超过阈值，直接跑下一次循环
    			if(x1 > imageOld->width || y1 > imageOld->height)
    			{
    				continue;	//TODO
    			}
    			
    
                //在画板画出图像，这里其实有优化的空间，当前偷懒整个画板更新
                //实际上不需要，只需要更新上次画的红色格子区域就行，当前对性能有点损耗
    			for(unsigned int i = imageOld->height - 1; i > 0 ; i--)
    			{
    				for(unsigned int j = 0; j < imageOld->width; j++)
    				{
    					unsigned int point = (imageOld->height - i) * imageOld->width + j; 
    					putpixel(j, i, EGERGB(imageOld->data[point].red, 
    									       imageOld->data[point].green, 
    										   imageOld->data[point].blue));
    				}
    			}
    
    			//画出当前在运行的方框
    			rectangle(x0, y0, x1, y1);
    
                //在红色方框里边画5*5个小方框，为了大概看到每个方框像素点个数
    			int xStep = abs(x0-x1)/5;
    			int yStep = abs(y0-y1)/5;
    
    			for(int j = 1; j < 5; j++)
    			{
    				line(x0 + xStep * j, y0, x0 + xStep * j, y1 );
    				line(x0, y0 + yStep * j, x1, y0 + yStep * j );
    			}
    
    			//记录找到的脸对应的参数，用于未找到正确人脸，查看是哪些参数出了问题，可用于优化
    			float parameters[FACE_RECOGNITION_STEP_MAX] = {0};		
    			double confidenceTemp = Classifier_decisionStump(IGmap, x0, y0, x1, y1, parameters);
    			if (confidenceTemp > 60.2f)
    			{
    			    DEBUG_PRINT_WITH_TIME("FaceCount: %d, confidenceTemp: %lf, x0: %d, y0: %d, x1: %d, y1: %d\n", FaceCount + 1, confidenceTemp, x0, y0, x1, y1);
    			    FoundFaces[FaceCount].x0 = x0;
    			    FoundFaces[FaceCount].x1 = x1;
    			    FoundFaces[FaceCount].y0 = y0;
    			    FoundFaces[FaceCount].y1 = y1;
    			    FoundFaces[FaceCount].angle = angle;
    			    for (int i = 0; i < FACE_RECOGNITION_STEP_MAX; i++)
        			{
         			    FoundFaces[FaceCount].parameters[i] = parameters[i];
         			    DEBUG_PRINT_WITH_TIME("%s%f，实际: %f", gExpectants[i].Note, gExpectants[i].ExpectantValue, parameters[i]);
        			} 
    			    FaceCount++;
    			    y0 += FaceHeight;
    			    x0 += FaceWidth;
    			    DEBUG_PRINT_WITH_TIME("\n");
    			    //getch();
    			}
    
    			//Sleep(100);	
    		}
    		
    		Sleep(1);
    	}
    
        for (int i = 0; i < FaceCount; i++)
        {
            rectangle(FoundFaces[i].x0, FoundFaces[i].y0, FoundFaces[i].x1, FoundFaces[i].y1);
            DEBUG_PRINT_WITH_TIME("FoundFaces: %d, angle: %d: x0: %d, y0: %d, x1: %d, y1: %d", i + 1, angle, FoundFaces[i].x0,  FoundFaces[i].y0, FoundFaces[i].x1, FoundFaces[i].y1);
            for (int j = 0; j < FACE_RECOGNITION_STEP_MAX; j++)
                DEBUG_PRINT_WITH_TIME("%s%f，实际: %f", gExpectants[j].Note, gExpectants[j].ExpectantValue, FoundFaces[i].parameters[j]);
            printf("\n");
            Sleep(1);
        }
    	
        // 窗口区域的取值范围
    	//getch();
    	//closegraph();
        return FaceCount;
     }
    
    // 画出人框
    void Image_draw(IMAGE_SELF *imageOld, FACE_RESULT *faceResult, int FaceCount)
    {
        int width = imageOld->width;
        int height = imageOld->height;
    
        for (int count = 0; count < FaceCount; count++)
        {
            int x0 = faceResult[count].x0;
            int y0 = faceResult[count].y0;
            int x1 = faceResult[count].x1;
            int y1 = faceResult[count].y1;
            int LineWidth = 4;
            y0 = height - y0;
            y1 = height - y1;
    
            int temp = y0;
            y0 = y1;
            y1 = temp;
            
            //竖
            for (int i = y0; i < y1; i++)
            {
            	for (int j = 0; j < LineWidth; j++)
            	{
    	            imageOld->data[i * width + x0 + j].blue = 0;
    	            imageOld->data[i * width + x0 + j].green = 0;
    	            imageOld->data[i * width + x0 + j].red = 200;	
    	            imageOld->data[i * width + x1 - j].blue = 0;
    	            imageOld->data[i * width + x1 - j].green = 0;
    	            imageOld->data[i * width + x1 - j].red = 200; 
    			}         
            }
            
            //横
            for (int i = x0; i < x1; i++)
            {
            	for (int j = 0; j < LineWidth; j++)
            	{
    	            imageOld->data[(y0 + j) * width + i].blue = 0;
    	            imageOld->data[(y0 + j) * width + i].green = 0;
    	            imageOld->data[(y0 + j) * width + i].red = 200;
    		        imageOld->data[(y1 - j) * width + i].blue = 0;
    	            imageOld->data[(y1 - j) * width + i].green = 0;
    	            imageOld->data[(y1 - j) * width + i].red = 200;  			
    			}
            }
        }
    }
    
    //积分图保存
    int IG_ImageSave(IGIMAGE_SELF *IGmap1, char *OutputFile)
    {
        IMAGE_SELF *image36;    
        image36 = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF) );
        image36->width = IGmap1->width;
        image36->height = IGmap1->height;
        image36->data = (BGRA *)malloc(sizeof(BGRA) * IGmap1->width * IGmap1->height);
        
        for (unsigned int i = 0; i < IGmap1->width * IGmap1->height; i++)
        {
            image36->data[i].red = IGmap1->data[i] % 256;
            image36->data[i].green = IGmap1->data[i] / 256 % 256;
            image36->data[i].blue = IGmap1->data[i] / 256 / 256 % 256;
            image36->data[i].transparency = 0;
            //if (i %1000 == 0)
            //  DEBUG_PRINT_WITH_TIME("w: %d, h: %d, i: %d", image35.width, image35.h, i);
        }
        
        Image_save(OutputFile, image36);    
        
        DEBUG_PRINT_WITH_TIME("1")
        for(unsigned int i = 0; i < IGmap1->width * IGmap1->height; i++)
        {
            //printf("%d ", IGmap1->data[i]);
            if((i + 1) % IGmap1->width == 0 )
            {
                //putchar('\n');
            }
        }
    
    }
    
    
    int IG_ImageWhirl(IGIMAGE_SELF *IGmap1, char *OutputFile)
    {
        //准备旋转积分图，用于人脸旋转识别测试
        //当前准备沿着图像横轴和纵轴中心旋转
        IMAGE_SELF *image37;    
        image37 = (IMAGE_SELF *)malloc(sizeof(IMAGE_SELF) );
        if (NULL == image37)
        {
            DEBUG_PRINT_WITH_TIME("memory allocate failed...")
            return -1;
        }
        int NewWidth = IGmap1->width * 2;
        int NewHeight = IGmap1->height * 2;
        image37->width = NewWidth;
        image37->height = NewHeight;
        DEBUG_PRINT_WITH_TIME("memory allocate: %d", 4 * NewWidth * NewWidth)
        image37->data = (BGRA *)malloc(4 * NewWidth * NewWidth);
        if (NULL == image37->data)
        {
            DEBUG_PRINT_WITH_TIME("memory allocate failed...")
            return -1;
        }
    
        int OldHeight = IGmap1->height;
        int OldWidth = IGmap1->width;
    
        int OldCenterHeight = OldHeight / 2;
        int OldCenterWidth = OldWidth / 2;
        
        int NewCenterWidth = NewWidth / 2;
        int NewCenterHeight = NewHeight / 2;
        
        //度数
        //double AngleAdd = 45 * PI / 180;
        double AngleAdd = 0;
        double Angle = 0;
        
        //旋转
        //for (int height = 2; height < OldHeight; height++)
        for (int height = 0; height < OldHeight; height++)
        {
            for (int width = 0; width < OldWidth; width++)
            //for (int width = 2; width < OldWidth; width++)
            {
                //当前点到中心点的距离
                int HeightTemp = height - OldCenterHeight;            
                int WidthTemp = width - OldCenterWidth;
                
                int HeightAbsTemp = abs(HeightTemp);
                int WidthAbsTemp = abs(WidthTemp);
                int Radius = sqrt(HeightAbsTemp * HeightAbsTemp + WidthAbsTemp * WidthAbsTemp);
                
                if(Radius != 0) //半径为0时，计算出来的Angle会有问题
                {
                    Angle = asin((double)WidthAbsTemp / Radius);
                }
                
                if (height > OldCenterHeight && width > OldCenterWidth)  //第一象限 （0，PI/2）
                {
                    //不用管
                }
                else if (height >= OldCenterHeight && width <= OldCenterWidth) //第二象限 （PI/2，PI）
                {
                    Angle += PI/2;
                }           
                else if (height <= OldCenterHeight && width <= OldCenterWidth) //第三象限 （PI，3PI/2）
                {
                    Angle += PI;
                }           
                else if (height <= OldCenterHeight && width >= OldCenterWidth) //第四象限 （3PI/2，2PI）
                {
                    Angle += 3 * PI/2;
                }
                
                double NewAngle = Angle + AngleAdd;
                int NewY, NewX;
    
                if (Angle > 0 && Angle < PI/2 || Angle > PI && Angle < 3*PI/2)
                {
                    //求新的x, y坐标点
                    NewY = Radius * cos(NewAngle);            
                    NewX = Radius * sin(NewAngle);
                }
                else
                {
                    NewX = Radius * cos(NewAngle);            
                    NewY = Radius * sin(NewAngle);
                }
                /*
                DEBUG_PRINT_WITH_TIME("width: %d, height: %d, Radius: %d, Angle: %lf, NewAngle: %lf, NewX: %d, NewY: %d", 
                                        width, 
                                        height, 
                                        Radius,
                                        Angle, 
                                        NewAngle, 
                                        NewX, 
                                        NewY)
                                        */
                //沿中心旋转
                int location = (NewCenterHeight + NewY) * NewWidth + NewCenterWidth + NewX;
                int location2 = height * OldWidth + width;
                //DEBUG_PRINT_WITH_TIME("location: %d, location2: %d", 
                //                                  location, 
                //                                  location2)
                if(location < 0)
                {
                    DEBUG_PRINT_WITH_TIME("location < 0");
                    break;
                }
                
                if(location2 < 0)
                {
                    DEBUG_PRINT_WITH_TIME("location2 < 0");
                    break;
                }
                image37->data[location].red   = IGmap1->data[location2] % 256;
                image37->data[location].green = IGmap1->data[location2] / 256 % 256;
                image37->data[location].blue  = IGmap1->data[location2] / 256 / 256 % 256;
                image37->data[location].transparency = 0;
            }
        }
        
        Image_save(OutputFile, image37);  
    
    }
    
    char InputFile[100] = {0};
    char OutputFile[100] = {0};
    
    FileNameInitial()
    {
        char InputPath[100] = "../Input/";
        char OutputPath[100] = "../Output/";
        
        char InputFileName[50] = "InputTest_04.bmp";
        char OutputFilename[100] = "_Result00.bmp";
    
        
        DEBUG_PRINT_WITH_TIME("main start....");
    
    
        strcpy(InputFile, InputPath);
        strcpy(OutputFile, OutputPath);
        
        strcat(InputFile, InputFileName);
        
        strcat(OutputFile, InputFileName);  
        OutputFile[strlen(OutputFile) - 4] = '_';
        
        strcat(OutputFile, OutputFilename);
    }
    
    
    int main()
    {
        FileNameInitial();
        
    	// 用于处理
    	IMAGE_SELF *image1 = Image_load(InputFile);
        if (image1 == NULL)
        {
            DEBUG_PRINT_WITH_TIME("readBMP file Abnormal...")
            return -1;
        }
    		
    	// 灰度图
    	IMAGE_SELF *image3 = Transform_color_grayscale(image1, GRAY_MODE_WEIGHT);
    	Image_save(OutputFile, image3);
    	
    	// 均值滤波
    	IMAGE_SELF *image4 = Wavefiltering_Average(image3);
    	Image_save(OutputFile, image4);
    	
    	// 二值图加边缘检测
    	IMAGE_SELF *image5 = Transform_color_BW_Adaptive(image4, 25);
    	Image_save(OutputFile, image5);
    
    	// 积分图
    	IGIMAGE_SELF *IGmap1 = IntegralImage_get(image5);
    
        IG_ImageSave(IGmap1, OutputFile);
    
    	//假设能找到FaceCountExpect张脸
        int FaceCountExpect = 1000;
    	FACE_RESULT *faceResult = (FACE_RESULT *)malloc(FaceCountExpect * sizeof(FACE_RESULT));
    	memset(faceResult, 0, FaceCountExpect * sizeof(FACE_RESULT));
    	
        ExpectantsInitial();
        
        GraphicsInitial(image1);
    
        for (angle = 10; angle < 360; angle += 10)
        {
            //旋转图像
            IMAGE_SELF *image6 = Transform_shape_whirl(image5, angle);
            Image_save(OutputFile, image6);
            
            // 旋转图像积分图
            IGIMAGE_SELF *IGmap2 = IntegralImage_get(image6);
            
            IG_ImageSave(IGmap2, OutputFile);
                
            // 滑动窗口
            FaceCount += MoveWindowArea(image6, IGmap2, faceResult);        
            Sleep(200);
        }
    
    	// 画出人脸框
    	Image_draw(image1, faceResult, FaceCount);
    
    
        //ManualMode(image5, IGmap1);
    	
    	// 保存图片
    	Image_save(OutputFile, image1);
    	
    	// 释放积分图
    	IntegralImage_free(IGmap1);
    	
    	// 释放图片资源 
    	Image_free(image1);
    	//Image_show(saveFilename);
    	
    	return 0;
    }

新代码测试如下图片的结果如下：

![5c584659abe34fb0ad59af170272dd1e.bmp][]

![1783895f46974ea68e715ea6a44aac0d.jpeg][]

图片旋转后生成的积分图（20230717更新），当前人脸检测出来太多人脸，代码有BUG，需要修复：

![0130fc62cbc94d9c9279c2c8900a70a1.bmp][]

![8dbef07a7265484184eb749787d227e7.bmp][]

![792c0c840b9b4856a248fdaef366e062.bmp][]

![4ef37f4c77fd42bc9a4f28b4704219de.bmp][]

当前的积分图是每次旋转10度，一共需要旋转35次，因为0度不需要旋转，但是图片里 是有BUG的，有的图片在旋转的过程已经跑图片外边去了。。。。：

![4d4c8514b595462f96beb5b8f87dc9a0.jpeg][]

参考：

[人脸检测：经典的VJ人脸检测器（类Harr特征，积分图加速法，级联的Adaboost强分类器）\_vj算法\_cartes1us的博客-CSDN博客][VJ_Harr_Adaboost_vj_cartes1us_-CSDN]

[FaceRecognition2_ _C]: https://gitee.com/r77683962/face-recognition2
[ca2ab357910747c896df731c931999e5.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/aeaa3b9b77054dd896c3ec552e47eb3c.png
[548768375ff54686bcead19f09825e4f.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/0f288e7ab2824ff4aca499efe8ca4fe3.png
[f80255d2a8404206a7181190b05e9921.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/4f9804591746463c92eee585052cdb52.png
[60011583d8ea4e2a9eaec4b311b12610.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ae03ce07a39149228b2261ea6a9a5af2.png
[d931fcb6acb34be9aa96892058103be2.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e146df7563a741389fb54a35e85f93ea.png
[b8c3cdefc8a64ad1a5a81ec8de8256ac.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1eac05051d7d477cb63fd5f87e36cd1b.png
[552739468dfb40aa89b90f1f6b662ae9.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/156c916c05d84a55b42f4af9fbb1c658.png
[5c584659abe34fb0ad59af170272dd1e.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/fbaec6c0681c48d78d11dbbe4885007d.png
[1783895f46974ea68e715ea6a44aac0d.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/f74dfc0bc2a14745a27039921cdcf061.png
[0130fc62cbc94d9c9279c2c8900a70a1.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/ae2f7755ce7a480bae5f4021d990eaf8.png
[8dbef07a7265484184eb749787d227e7.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/bcd8bb06452f4c048ea4b66bed5f49d5.png
[792c0c840b9b4856a248fdaef366e062.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/00e2d30444e94de088d47fc1a1b02e0b.png
[4ef37f4c77fd42bc9a4f28b4704219de.bmp]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e45eb0fcfca54c16a23394ea2f1d65b1.png
[4d4c8514b595462f96beb5b8f87dc9a0.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/72834f2a0edc442d9f84d411e7835bf7.png
[VJ_Harr_Adaboost_vj_cartes1us_-CSDN]: https://blog.csdn.net/kill2013110/article/details/127105998