Chinaunix首页 | 论坛 | 博客

zhujiangzhujiang.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

zhujiang73

  • 博客访问： 434400
  • 博文数量： 53
  • 博客积分： 6243
  • 博客等级： 大校
  • 技术积分： 567
  • 用 户 组： 普通用户
  • 注册时间： 2006-07-08 18:00
文章分类

全部博文（53）

文章存档

2013年（1）

2011年（20）

2010年（28）

2007年（3）

2006年（1）

我的朋友
最近访客
推荐博文
相关博文
用局部边沿方向特征做图像识别目标检测（一）

分类： C/C++

2011-02-23 19:44:35


      以前我用 gabor 和 adaboost 做过图像识别，

现在用另一种方法试试。首先把做卷积的 gabor 核改一下加强方向性。
  1. ZeGabor::ZeGabor(double dPhi, double dNu, double dSigma, double dF)
  2. {
  3.     double Sigma = dSigma;
  4.     double F = dF;

  6.     double Kmax = PI/2;

  8.     // Absolute value of K
  9.     double K = Kmax / pow(F, dNu);
  10.     double Phi = dPhi;

  12.         double dModSigma = Sigma/K;

  14.         double dWidth = cvRound(dModSigma*6 + 1);

  16.         if (fmod(dWidth, 2.0)==0.0) dWidth++;

  18.     Width = (long)dWidth;

  20.     Real = cvCreateMat( Width, Width, CV_32FC1);
  21.     Imag = cvCreateMat( Width, Width, CV_32FC1);

  23.         CvMat *mReal, *mImag;
  24.         mReal = cvCreateMat( Width, Width, CV_32FC1);
  25.         mImag = cvCreateMat( Width, Width, CV_32FC1);

  27.         double a, b;
  28.         double c;
  29.         double x, y;
  30.         double ra, rb;
  31.         double dReal;
  32.         double dImag;
  33.         double dTemp1, dTemp2, dTemp3;

  35.         a = 0.4;
  36.         b = 1.0;
  37.         c = dPhi;


  40.         for (int i = 0; i < Width; i++)
  41.         {
  42.             for (int j = 0; j < Width; j++)
  43.             {
  44.                 x = i-(Width-1)/2;
  45.                 y = j-(Width-1)/2;

  47.                 ra = x*cos(c) + y*sin(c);
  48.                 rb = -x*sin(c) + y*cos(c);

  50.                 dTemp1 = (K*K/Sigma*Sigma)*exp(-(ra*ra/(a*a)+rb*rb/(b*b))*K*K/(2*Sigma*Sigma));
  51.                 dTemp2 = cos(K*cos(Phi)*1.5*x + K*sin(Phi)*1.5*y) - exp(-(pow(Sigma,2)/2));
  52.                 dTemp3 = sin(K*cos(Phi)*1.5*x + K*sin(Phi)*1.5*y);


  55.                 dReal = dTemp1*dTemp2;
  56.                 dImag = dTemp1*dTemp3;

  58.                 cvSetReal2D((CvMat*)mReal, i, j, dReal );
  59.                 cvSetReal2D((CvMat*)mImag, i, j, dImag );
  60.             }
  61.         }
  62.         /**************************** Gabor Function ****************************/
  63.         cvCopy(mReal, Real, NULL);
  64.         cvCopy(mImag, Imag, NULL);
  65.         //printf("A %d x %d Gabor kernel with %f PI in arc is created.\n", Width, Width, Phi/PI);
  66.         cvReleaseMat( &mReal );
  67.         cvReleaseMat( &mImag );
  68. }


这图经过放大，实际用的卷积核比这个小很多。用一组不同方向的 ZeGabor 核和图像作卷积，在卷积结果
图中，图像的边沿部分的坐标点上的不同方向结果中会有某一个或几个比平均值大很多，取这样的点做特征
点，这些方向做特征值，可以构成一组特征用于图像识别。



这是要识别的目标图像的标准图，右图上的黄点是取得的特征点，特征点上的特征值是此点上的图像边沿方
向。

提取标准图的特征：
  1. IplImage *img_gray = cvCreateImage( cvGetSize(img_src), 8, 1 );

  3.         cvCvtColor(img_src, img_gray, CV_BGR2GRAY);

  5.         CvMat *mat_edge = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);
  6.         CvMat *mat_dire = cvCreateMat(img_gray->height, img_gray->width, CV_32SC1);
  7.         CvMat *mat_mask = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);

  9.         CvMat *mat_max_dire = cvCreateMat(img_gray->height, img_gray->width, CV_32SC1);

  11.         CvMat *mat_mags[ZGDIRES];

  13.         for (int i=0; i<ZGDIRES; i++)
  14.         {
  15.                 mat_mags[i] = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);
  16.         }

  18.         ZeGabor *gabors[ZGDIRES];

  20.         double Sigma = 2*PI;
  21.         double F = sqrt(2.0);
  22.         double dn = ZGDN;

  24.         for (int n=0; n<ZGDIRES; n++)
  25.         {
  26.                 gabors[n] = new ZeGabor((PI/ZGDIRES)*n, dn, Sigma, F);
  27.         }

  29.         for (int n=0; n<ZGDIRES; n++)
  30.         {
  31.                 gabors[n]->conv_mat_mag(img_gray, mat_mags[n]);
  32.         }

  34.         for (int y=0; y<img_gray->height; y++)
  35.         {
  36.                 for (int x=0; x<img_gray->width; x++)
  37.                 {
  38.                         float sum;
  39.                         float average;
  40.                         float max_ve;
  41.                         int dire;

  43.                         sum = 0.0;
  44.                         dire = 0;
  45.                         max_ve = CV_MAT_ELEM(*mat_mags[0], float, y, x);

  47.                         for (int n=0; n<ZGDIRES; n++)
  48.                         {
  49.                                 float ve = CV_MAT_ELEM(*mat_mags[n], float, y, x);
  50.                                 sum += ve;
  51.                                 if (ve > max_ve)
  52.                                 {
  53.                                         max_ve = ve;
  54.                                         dire = n;
  55.                                 }
  56.                         }

  58.                         average = sum/ZGDIRES;

  60.                         CV_MAT_ELEM(*mat_edge, float, y, x) = 0;
  61.                         CV_MAT_ELEM(*mat_dire, int, y, x) = dire;

  63.                         if (max_ve > 4.0*average) CV_MAT_ELEM(*mat_edge, float, y, x) = 255;
  64.                 }
  65.         }

  67.         ZPoint zpoint;

  69.         for (int y=5; y<img_gray->height-5; y+=2)
  70.         {
  71.                 for (int x=5; x<img_gray->width-5; x+=2)
  72.                 {
  73.                         if (CV_MAT_ELEM(*mat_edge, float, y, x) > 254)
  74.                         {
  75.                                 zpoint.x = x;
  76.                                 zpoint.y = y;

  78.                                 zpoint.dire = CV_MAT_ELEM(*mat_dire, int, y, x);

  80.                                 filter_zpoints.push_back(zpoint);
  81.                         }
  82.                 }
  83.         }

  85.         std::cout << "filter_zpoints.size : " << filter_zpoints.size() << std::endl;

  87.         for (int i=0; i<ZGDIRES; i++)
  88.         {
  89.                 cvReleaseMat(&mat_mags[i]);
  90.         }
检测目标图像：
  1. IplImage *img_gray = cvCreateImage( cvGetSize(img_src), 8, 1 );
  2.         cvCvtColor(img_src, img_gray, CV_BGR2GRAY);

  4.         ZGFeature *p_zg_features = new ZGFeature[img_gray->height*img_gray->width];

  6.         CvMat *mat_edge = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);
  7.         CvMat *mat_dire = cvCreateMat(img_gray->height, img_gray->width, CV_32SC1);
  8.         CvMat *mat_mask = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);

  10.         CvMat *mat_mags[ZGDIRES];

  12.         for (int i=0; i<ZGDIRES; i++)
  13.         {
  14.                 mat_mags[i] = cvCreateMat(img_gray->height, img_gray->width, CV_32FC1);
  15.         }

  17.         ZeGabor *gabors[ZGDIRES];

  19.         double Sigma = 2*PI;
  20.         double F = sqrt(2.0);
  21.         double dn = ZGDN;

  23.         for (int n=0; n<ZGDIRES; n++)
  24.         {
  25.                 gabors[n] = new ZeGabor((PI/ZGDIRES)*n, dn, Sigma, F);
  26.         }

  28.         for (int n=0; n<ZGDIRES; n++)
  29.         {
  30.                 gabors[n]->conv_mat_mag(img_gray, mat_mags[n]);
  31.         }

  33.         for (int y=0; y<img_gray->height; y++)
  34.         {
  35.                 for (int x=0; x<img_gray->width; x++)
  36.                 {
  37.                         float sum;
  38.                         float average;
  39.                         float max_ve;
  40.                         int dire;

  42.                         sum = 0.0;
  43.                         dire = 0;
  44.                         max_ve = CV_MAT_ELEM(*mat_mags[0], float, y, x);

  46.                         ZGFeature *p_zg_f = p_zg_features + y*img_gray->width + x;

  48.                         for (int n=0; n<ZGDIRES; n++)
  49.                         {
  50.                                 float ve = CV_MAT_ELEM(*mat_mags[n], float, y, x);

  52.                                 p_zg_f->dire_ves[n] = ve;

  54.                                 sum += ve;
  55.                                 if (ve > max_ve)
  56.                                 {
  57.                                         max_ve = ve;
  58.                                         dire = n;
  59.                                 }
  60.                         }

  62.                         average = sum/ZGDIRES;

  64.                         p_zg_f->ve_average = average;

  66.                         CV_MAT_ELEM(*mat_edge, float, y, x) = 0;
  67.                         CV_MAT_ELEM(*mat_dire, int, y, x) = dire;
  68.                 }
  69.         }

  71.         for (int i=0; i<ZGDIRES; i++)
  72.         {
  73.                 cvReleaseMat(&mat_mags[i]);
  74.         }

  76.         int num_zpoints = filter_zpoints.size();

  78.         ScanPoint scan_point;

  80.         for (int y=0; y<img_gray->height-100; y+=2)
  81.         {
  82.                 for(int x=0; x<img_gray->width-100; x+=2)
  83.                 {
  84.                         int zclass = 0;

  86.                         for (std::vector<ZPoint>::iterator i = filter_zpoints.begin(); i != filter_zpoints.end(); i++)
  87.                         {
  88.                                 int x1 = x + i->x;
  89.                                 int y1 = y + i->y;

  91.                                 ZGFeature *p_zg_f = p_zg_features + y1*img_gray->width + x1;

  93.                                 int num_mask = p_zg_f->num_mask;
  94.                                 int dire = i->dire;

  96.                                 if(p_zg_f->dire_ves[dire] > 2.0*p_zg_f->ve_average)
  97.                                 {
  98.                                        zclass++;
  99.                                 }
  100.                         }

  102.                         if ((float)zclass/(float)num_zpoints > SCANTHRE)
  103.                         {
  104.                                 scan_point.x = x+IMGTW/2;
  105.                                 scan_point.y = y+IMGTH/2;

  107.                                 scan_points.push_back(scan_point);
  108.                         }
  109.                 }

  111.                 std::cout << y << std::endl;
  112.         }
运行截图：


检测结果，目标被蓝圈标识出来了。

    这个方法需要算一组检测图的卷积，这部分计算量比较大，但是如果使用 OpenCL 等并行计算技术应
该可以大大加速，下一步我准备处理目标的大小和方向变化这部分可能还比较简单，然后准备处理立体的目
标，这个可能比较复杂，目前的想法是对一个立体目标的不同角度分别取特征处理，只是这样计算量会比较
大。

                                                                            zhujiang
                                                                           2011.02.23

----------------------------------------------------------------------------------------

    这几天又做了些实验，这个算法效果还不错，对光线变化和局部遮挡也不大敏感，就是速度比较慢，T6670 2.2G CPU 单线程检测一幅 800*600 的图像，旋转范围左右大约各 20 度，缩放 1.0 到 1.5 倍，大约用几十秒。


    这样如果要根据一组不同角度的照片的特征去识别一个立体目标就必须加快处理速度，算法应该还可以改进，再有就是用 OpenCL 等平行处理技术了，这个局部边沿方向特征算法应该是适合并行化的，理论上中高端显卡上的 GPU 跑并行化的算法可以提速几十到几百倍，不过我的 4570 入门级小显卡估计效果有限。 :-)

                                                                            zhujiang
                                                                            2011.3.3

                                                                        

阅读(5591) | 评论(8) | 转发(0) |
0

上一篇：Lock On 模拟飞行，机炮格斗

下一篇：这猫真是命好

给主人留下些什么吧！~~

网络安全服务2011-10-25 09:13:50

回复 | 举报

zhujiang732011-04-04 13:55:36

Josephine_wang: 请问博主有没有做过边缘检测方面的东西？~也是用matlab实现的？~~~请问有没好的建议？~
gabor 可以做边缘检测，优点是对噪声不太敏感，但是计算量比较大。没用过 matlab 我一般是用 C/C++ 和 OpenCV 。

回复 | 举报

Josephine_wang2011-04-04 08:59:01

请问博主有没有做过边缘检测方面的东西？~也是用matlab实现的？~~~请问有没好的建议？~

回复 | 举报

zhujiang732011-04-02 10:35:11

abyssecho: 您好，能否给我一份完整的工程文件，因为毕设继续用，谢谢您啊！真的很着急，我一直没做出来abyssecho@hotmail.com
要拿我这个对付你们教授？这样不好吧。

回复 | 举报

abyssecho2011-04-02 09:13:46

您好，能否给我一份完整的工程文件，因为毕设继续用，谢谢您啊！真的很着急，我一直没做出来abyssecho@hotmail.com

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6