gabor函数的c++实现

最新推荐文章于 2024-04-13 19:47:12 发布
最新推荐文章于 2024-04-13 19:47:12 发布
阅读量743 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rxm1989/article/details/39550257
版权
Gabor2.h

#ifndef CVGABOR_H
#define CVGABOR_H

#include <iostream>


#include <cv.h>
#include <highgui.h>

#define PI 3.14159265
#define CV_GABOR_REAL 1
#define CV_GABOR_IMAG 2
#define CV_GABOR_MAG   3
#define CV_GABOR_PHASE 4

class CvGabor{
public:
CvGabor();
~CvGabor();


CvGabor(int iMu, int iNu, double dSigma);
CvGabor(int iMu, int iNu, double dSigma, double dF);
CvGabor(double dPhi, int iNu);
CvGabor(double dPhi, int iNu, double dSigma);
CvGabor(double dPhi, int iNu, double dSigma, double dF);
bool IsInit();
long mask_width();
IplImage* get_image(int Type);
bool IsKernelCreate();
long get_mask_width();
void Init(int iMu, int iNu, double dSigma, double dF);
void Init(double dPhi, int iNu, double dSigma, double dF);
void output_file(const char *filename, int Type);
CvMat* get_matrix(int Type);
void show(int Type);
void conv_img(IplImage *src, IplImage *dst, int Type);
CvGabor(int iMu, int iNu);
void normalize( const CvArr* src, CvArr* dst, double a, double b, int norm_type, const CvArr* mask );
void conv_img_a(IplImage *src, IplImage *dst, int Type);

protected:
double Sigma;
double F;
double Kmax;
double K;
double Phi;
bool bInitialised;
bool bKernel;
long Width;
CvMat *Imag;
CvMat *Real;

private:
void creat_kernel();


};

#endif


Gabor2.cpp


#include "Gabor2.h"


#define   round(x)   ((int)(x   +   0.5))    

CvGabor::CvGabor()
{
}


CvGabor::~CvGabor()
{
cvReleaseMat( &Real );
cvReleaseMat( &Imag );
}




CvGabor::CvGabor(int iMu, int iNu, double dSigma)
{ 
    F = sqrt(2.0);
    Init(iMu, iNu, dSigma, F);
}


  CvGabor::CvGabor(int iMu, int iNu, double dSigma, double dF)
{

    Init(iMu, iNu, dSigma, dF);
     
}


  CvGabor::CvGabor(double dPhi, int iNu)
{
    Sigma = 2*PI;
    F = sqrt(2.0);
    Init(dPhi, iNu, Sigma, F);
}


  CvGabor::CvGabor(double dPhi, int iNu, double dSigma)
{

    F = sqrt(2.0);
    Init(dPhi, iNu, dSigma, F);
}


  CvGabor::CvGabor(double dPhi, int iNu, double dSigma, double dF)
{

    Init(dPhi, iNu, dSigma,dF);
}

bool CvGabor::IsInit()
{

    return bInitialised;
}

long CvGabor::mask_width()
{

    long lWidth;
    if (IsInit() == false)   {
        perror ("Error: The Object has not been initilised in mask_width()!\n");
        return 0;
    }
    else {
        //determine the width of Mask
      double dModSigma = Sigma/K;
      double dWidth = round(dModSigma*6 + 1);

      //test whether dWidth is an odd.
      if (fmod(dWidth, 2.0)==0.0) dWidth++;
      lWidth = (long)dWidth;

      return lWidth;
    }
}


void CvGabor::creat_kernel()
{
     
    if (IsInit() == false) {perror("Error: The Object has not been initilised in creat_kernel()!\n");}
    else {
      CvMat *mReal, *mImag;
      mReal = cvCreateMat( Width, Width, CV_32FC1);
      mImag = cvCreateMat( Width, Width, CV_32FC1);
       
       
      int x, y;
      double dReal;
      double dImag;
      double dTemp1, dTemp2, dTemp3;

      for (int i = 0; i < Width; i++)
      {
          for (int j = 0; j < Width; j++)
          {
              x = i-(Width-1)/2;
              y = j-(Width-1)/2;
              dTemp1 = (pow(K,2)/pow(Sigma,2))*exp(-(pow((double)x,2)+pow((double)y,2))*pow(K,2)/(2*pow(Sigma,2)));
              dTemp2 = cos(K*cos(Phi)*x + K*sin(Phi)*y) - exp(-(pow(Sigma,2)/2));
              dTemp3 = sin(K*cos(Phi)*x + K*sin(Phi)*y);
              dReal = dTemp1*dTemp2;
              dImag = dTemp1*dTemp3; 
              //gan_mat_set_el(pmReal, i, j, dReal);
      //cvmSet( (CvMat*)mReal, i, j, dReal );
cvSetReal2D((CvMat*)mReal, i, j, dReal );
              //gan_mat_set_el(pmImag, i, j, dImag);
              //cvmSet( (CvMat*)mImag, i, j, dImag );
cvSetReal2D((CvMat*)mImag, i, j, dImag );

          } 
        }
       
        bKernel = true;
        cvCopy(mReal, Real, NULL);
        cvCopy(mImag, Imag, NULL);
      //printf("A %d x %d Gabor kernel with %f PI in arc is created.\n", Width, Width, Phi/PI);
        cvReleaseMat( &mReal );
        cvReleaseMat( &mImag );
      }
}


IplImage* CvGabor::get_image(int Type)
{

    if(IsKernelCreate() == false)
    { 
      perror("Error: the Gabor kernel has not been created in get_image()!\n");
      return NULL;
    }
    else
    {  
    IplImage* pImage;
    IplImage *newimage;
    newimage = cvCreateImage(cvSize(Width,Width), IPL_DEPTH_8U, 1 );
    //printf("Width is %d.\n",(int)Width);
    //printf("Sigma is %f.\n", Sigma);
    //printf("F is %f.\n", F);
    //printf("Phi is %f.\n", Phi);
     
    //pImage = gan_image_alloc_gl_d(Width, Width);
    pImage = cvCreateImage( cvSize(Width,Width), IPL_DEPTH_32F, 1 );
     
     
    CvMat* kernel = cvCreateMat(Width, Width, CV_32FC1);
    double ve;
    CvScalar S;
    CvSize size = cvGetSize( kernel );
    int rows = size.height;
    int cols = size.width;
    switch(Type)
    {
        case 1:   //Real

            cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
            //pImage = cvGetImage( (CvMat*)kernel, pImageGL );
            for (int i = 0; i < rows; i++)
      {
              for (int j = 0; j < cols; j++)
              {
                    ve = cvGetReal2D((CvMat*)kernel, i, j);
                    cvSetReal2D( (IplImage*)pImage, j, i, ve );
              }
            }
            break;
        case 2:   //Imag
            cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
            //pImage = cvGetImage( (CvMat*)kernel, pImageGL );
            for (int i = 0; i < rows; i++)
      {
              for (int j = 0; j < cols; j++)
              {
                    ve = cvGetReal2D((CvMat*)kernel, i, j);
                    cvSetReal2D( (IplImage*)pImage, j, i, ve );
              }
            }
            break; 
        case 3:   //Magnitude
            ///@todo  
            break;
        case 4:   //Phase
          ///@todo
            break;
    }
   
    cvNormalize((IplImage*)pImage, (IplImage*)pImage, 0, 255, CV_MINMAX, NULL );


    cvConvertScaleAbs( (IplImage*)pImage, (IplImage*)newimage, 1, 0 );

    cvReleaseMat(&kernel);

    cvReleaseImage(&pImage);

    return newimage;
    }
}


bool CvGabor::IsKernelCreate()
{

    return bKernel;
}


long CvGabor::get_mask_width()
{
  return Width;
}


void CvGabor::Init(int iMu, int iNu, double dSigma, double dF)
{
  //Initilise the parameters 
    bInitialised = false;
    bKernel = false;

    Sigma = dSigma;
    F = dF;
     
    Kmax = PI/2;
     
    // Absolute value of K
    K = Kmax / pow(F, (double)iNu);
    Phi = PI*iMu/8;
    bInitialised = true;
    Width = mask_width();
    Real = cvCreateMat( Width, Width, CV_32FC1);
    Imag = cvCreateMat( Width, Width, CV_32FC1);
    creat_kernel();  
}

void CvGabor::Init(double dPhi, int iNu, double dSigma, double dF)
{

    bInitialised = false;
    bKernel = false;
    Sigma = dSigma;
    F = dF;
     
    Kmax = PI/2;
     
    // Absolute value of K
    K = Kmax / pow(F, (double)iNu);
    Phi = dPhi;
    bInitialised = true;
    Width = mask_width();
    Real = cvCreateMat( Width, Width, CV_32FC1);
    Imag = cvCreateMat( Width, Width, CV_32FC1);
    creat_kernel();  
}



CvMat* CvGabor::get_matrix(int Type)
{
    if (!IsKernelCreate()) {perror("Error: the gabor kernel has not been created!\n"); return NULL;}
    switch (Type)
    {
      case CV_GABOR_REAL:
        return Real;
        break;
      case CV_GABOR_IMAG:
        return Imag;
        break;
      case CV_GABOR_MAG:
        return NULL;
        break;
      case CV_GABOR_PHASE:
        return NULL;
        break;
    }
}




void CvGabor::output_file(const char *filename, int Type)
{
  IplImage *pImage;
  pImage = get_image(Type);
  if(pImage != NULL)
  {
    if( cvSaveImage(filename, pImage )) printf("%s has been written successfully!\n", filename);
    else printf("Error: writting %s has failed!\n", filename);
  }
  else 
    perror("Error: the image is empty in output_file()!\n"); 

  cvReleaseImage(&pImage);
}






void CvGabor::show(int Type)
{
    if(!IsInit()) {
        perror("Error: the gabor kernel has not been created!\n");
    }
    else {
      //     IplImage *pImage;
      //pImage = get_image(Type);
      //cvNamedWindow("Testing",1);
      //cvShowImage("Testing",pImage);
      //cvWaitKey(0);
      //cvDestroyWindow("Testing");
      //cvReleaseImage(&pImage);
    }

}




void CvGabor::conv_img_a(IplImage *src, IplImage *dst, int Type)
{
    double ve, re,im;
   
    int width = src->width;
    int height = src->height;
    CvMat *mat = cvCreateMat(src->width, src->height, CV_32FC1);
     
    for (int i = 0; i < width; i++)
    {
        for (int j = 0; j < height; j++)
        {
              ve = cvGetReal2D((IplImage*)src, j, i);
              cvSetReal2D( (CvMat*)mat, i, j, ve );
        }
    }

    CvMat *rmat = cvCreateMat(width, height, CV_32FC1);
    CvMat *imat = cvCreateMat(width, height, CV_32FC1);

    CvMat *kernel = cvCreateMat( Width, Width, CV_32FC1 );

    switch (Type)
    {
      case CV_GABOR_REAL:
        cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
        cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
        break;
      case CV_GABOR_IMAG:
        cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
        cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
        break;
      case CV_GABOR_MAG:
       
        cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL );
        cvFilter2D( (CvMat*)mat, (CvMat*)rmat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
       
        cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL );
        cvFilter2D( (CvMat*)mat, (CvMat*)imat, (CvMat*)kernel, cvPoint( (Width-1)/2, (Width-1)/2));
       
        for (int i = 0; i < width; i++)
        {
            for (int j = 0; j < height; j++)
            {
                re = cvGetReal2D((CvMat*)rmat, i, j);
                im = cvGetReal2D((CvMat*)imat, i, j);
                ve = sqrt(re*re + im*im);
                cvSetReal2D( (CvMat*)mat, i, j, ve );
            }
        }        
        break;
      case CV_GABOR_PHASE:
        break;
    }
     
    if (dst->depth == IPL_DEPTH_8U)
    {
        cvNormalize((CvMat*)mat, (CvMat*)mat, 0, 255, CV_MINMAX, NULL);
    for (int i = 0; i < width; i++)
    {
            for (int j = 0; j < height; j++)
            {
                ve = cvGetReal2D((CvMat*)mat, i, j);
                ve = cvRound(ve);
                cvSetReal2D( (IplImage*)dst, j, i, ve );
            }
        }
      }

      if (dst->depth == IPL_DEPTH_32F)
      {
          for (int i = 0; i < width; i++)
    {
            for (int j = 0; j < height; j++)
            {
                ve = cvGetReal2D((CvMat*)mat, i, j);
                cvSetReal2D( (IplImage*)dst, j, i, ve );
            }
          }
      } 

    cvReleaseMat(&kernel);
    cvReleaseMat(&imat);
    cvReleaseMat(&rmat);
    cvReleaseMat(&mat);
}


  CvGabor::CvGabor(int iMu, int iNu)
{
  double dSigma = 2*PI; 
  F = sqrt(2.0);
  Init(iMu, iNu, dSigma, F);
}


void CvGabor::normalize( const CvArr* src, CvArr* dst, double a, double b, int norm_type, const CvArr* mask )
{
    CvMat* tmp = 0;
//     __BEGIN__;

    double scale, shift;
     
    if( norm_type == CV_MINMAX )
    {
        double smin = 0, smax = 0;
        double dmin = MIN( a, b ), dmax = MAX( a, b );
        cvMinMaxLoc( src, &smin, &smax, 0, 0, mask );
        scale = (dmax - dmin)*(smax - smin > DBL_EPSILON ? 1./(smax - smin) : 0);
        shift = dmin - smin*scale;
    }
    else if( norm_type == CV_L2 || norm_type == CV_L1 || norm_type == CV_C )
    {
        CvMat *s = (CvMat*)src, *d = (CvMat*)dst;

        scale = cvNorm( src, 0, norm_type, mask );
        scale = scale > DBL_EPSILON ? 1./scale : 0.;
        shift = 0;
    }
    else {}

       
     
    if( !mask )
        cvConvertScale( src, dst, scale, shift );
    else
    {
        CvMat stub, *dmat;
 
       
        cvConvertScale( src, tmp, scale, shift );
        cvCopy( tmp, dst, mask );
    }

//     __END__;

    if( tmp )
        cvReleaseMat( &tmp );
}


void CvGabor::conv_img(IplImage *src, IplImage *dst, int Type)
{
  double ve, re,im;
   
  CvMat *mat = cvCreateMat(src->width, src->height, CV_32FC1);
  for (int i = 0; i < src->width; i++)
  {
    for (int j = 0; j < src->height; j++)
    {
      ve = CV_IMAGE_ELEM(src, uchar, j, i);
      CV_MAT_ELEM(*mat, float, i, j) = (float)ve;
    }
  }
   
  CvMat *rmat = cvCreateMat(src->width, src->height, CV_32FC1);
  CvMat *imat = cvCreateMat(src->width, src->height, CV_32FC1);
   
  switch (Type)
  {
  case CV_GABOR_REAL:
    cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)Real, cvPoint( (Width-1)/2, (Width-1)/2));
    break;
  case CV_GABOR_IMAG:
    cvFilter2D( (CvMat*)mat, (CvMat*)mat, (CvMat*)Imag, cvPoint( (Width-1)/2, (Width-1)/2));
    break;
  case CV_GABOR_MAG:
    cvFilter2D( (CvMat*)mat, (CvMat*)rmat, (CvMat*)Real, cvPoint( (Width-1)/2, (Width-1)/2));
    cvFilter2D( (CvMat*)mat, (CvMat*)imat, (CvMat*)Imag, cvPoint( (Width-1)/2, (Width-1)/2));
     
    cvPow(rmat,rmat,2); 
    cvPow(imat,imat,2);
    cvAdd(imat,rmat,mat); 
    cvPow(mat,mat,0.5); 
    break;
  case CV_GABOR_PHASE:
    break;
  }
   
  if (dst->depth == IPL_DEPTH_8U)
  {
    cvNormalize((CvMat*)mat, (CvMat*)mat, 0, 255, CV_MINMAX);
    for (int i = 0; i < mat->rows; i++)
    {
      for (int j = 0; j < mat->cols; j++)
      {
        ve = CV_MAT_ELEM(*mat, float, i, j);
        CV_IMAGE_ELEM(dst, uchar, j, i) = (uchar)cvRound(ve);
      }
    }
  }
   
  if (dst->depth == IPL_DEPTH_32F)
  {
    for (int i = 0; i < mat->rows; i++)
    {
      for (int j = 0; j < mat->cols; j++)
      {
        ve = cvGetReal2D((CvMat*)mat, i, j);
        cvSetReal2D( (IplImage*)dst, j, i, ve );
      }
    }
  }
  cvReleaseMat(&imat);
  cvReleaseMat(&rmat);
  cvReleaseMat(&mat);
}

test.cpp


#include "cv.h"
#include "highgui.h"
#include "Gabor2.h"

int main()
{
CvGabor filter1(0,0);//CvGabor(double dPhi, int iNu)a orientation dPhi, and with a scale iNu




IplImage *kernel = cvCreateImage( cvSize(filter1.get_mask_width(), filter1.get_mask_width()), IPL_DEPTH_8U, 1);
kernel = filter1.get_image(CV_GABOR_REAL);
cvNamedWindow("Gabor Kernel", 1);
cvShowImage("Gabor Kernel", kernel);
cvWaitKey(0);

return 0;

}
Rachel-Zhang3
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于opencv的Gabor滤波器设计（C++）版
u013308233的专栏
07-09 2456
一直在做人脸识别方向，想用一下Gabor滤波器做一下Gabor人脸。
gabor滤波的c++实现与该类得使用简介.doc
07-24
gabor滤波的c++实现与该类得使用简介 以及该类源代码文件的下载地址
Gabor变换 c++源码
11-24
基于opencv与vs2010实现的 gabor变换算法，已经过调试可用，代码思路清晰，阅读性强
C++图像Gabor特征提取Opencv版本
08-23
自己写的两种常用的图像Gabor特征提取算法，虽然现在matlab里已经有加进来的，但是工程实现和初学者作为较好的工具使用。真的良心
离散Gabor变换算法的C++实现
weixin_34365635的博客
09-09 243
2019独角兽企业重金招聘Python工程师标准>>> ...
Gabor函数
A1_abc的博客
09-13 816
Gabor变换属于加窗傅立叶变换，Gabor函数可以在频域不同尺度、不同方向上提取相关的特征。另外Gabor函数与人眼的生物作用相仿，所以经常用作纹理识别上，并取得了较好的效果。二维Gabor函数可以表示为： 其中： v的取值决定了Gabor滤波的波长，u的取值表示Gabor核函数的方向，K表示总的方向数。参数决定了高斯窗口的大小，这里取。程序中取4个频率（v=0, 1, ..., 3），8个...
Gabor-API:Gabor过滤器的C ++代码库实现
05-08
Gabor API 介绍 Gabor-API是Gabor过滤器的C ++代码库实现。 该API为用户提供了将Gabor过滤器应用于.PGM格式的图像的必要例程。 可选地，可以在Gabor卷积之前将对比度滤镜和对数极坐标变换应用于图像。 此外，该库有两个变体。 第一种变体实现了标准的Gabor滤波器方法，在该方法中，图像以不同方向和频率的可能重叠的Gabor滤波器组的网格卷积。 第二个变体在图像的所谓基准点处对Gabor滤波器组进行卷积。 这些基准点的坐标在文本文件中提供。 安装 将下载的tar.gz文件解压缩到您选择的目录中。 要编译该库，请导航至所需的子目录gabor-global/src/ （对于标准Gabor实现）或gabor-local/src/ （对于基准实现），然后发出make命令。 位于gabor-global/和gabor-local/的Makefile将基于库和Gabor
gabor函数基于opencv1.0实现
09-24
1、里面还是三个文件cvgabor.cpp cvgabor.h 和测试用的main.cpp 2、自己搭建opencv环境即可。 3、Copyright (C) 2006 by Mian Zhou * M.Zhou@reading.ac.uk *
gabor变化OpenCV实现
08-20
4. **θ角（Theta）**：决定Gabor函数的倾斜角度，对应于滤波器响应最强的方向。 5. **λ**：波长，与频率相对应，决定了滤波器的空间频率特性。 6. **γ**：比例因子，是空间频率与相位频率的比值，影响了滤波器...
gabor实现过程
07-17
1. **Gabor函数构造**：Gabor函数是一个复数高斯函数乘以正弦函数，参数包括频率、方向、尺度和位相。 2. **滤波器生成**：根据需求生成不同参数的Gabor核，形成滤波器组。 3. **卷积操作**：将滤波器与输入图像进行...
gabor 滤波的c++实现与该类得使用简介
03-01 306
下载cvgabor.cpp和cvgabor.h到你的C/C++工程目录下 注：在我的资源中有改进过的cvgabor类 相关链接为：http://download.csdn.net/source/490114 特别注意：使用该类需要OpenCV库的支持，如何配置环境参见：ht...
基于OpenCV实现的Gabor滤波
03-08
基于OpenCV实现的Gabor滤波，包含Gabor小波的基本介绍和代码实现
Gabor 函数：生成二维空间 Gabor 函数。 用于生成模型简单的细胞感受野。-matlab开发
06-01
生成二维空间 Gabor 函数。 用于生成模型简单的细胞感受野，或用于执行边缘检测。 参数允许指定空间频率、方向、宽度和中心。
【Gabor滤波器】提取图像纹理（Python、C++两种实现）
进一寸有一寸的欢喜
02-26 7969
主要参考：（后续链接重复） 分析opencv实现的gabor + 不同参数的gabor核（图）：https://blog.csdn.net/lhanchao/article/details/55006663 分析wiki百科的gabor实现：https://zhuanlan.zhihu.com/p/33311267 原理、opencv+c++实现：https://blog.csdn.net/ibelievesunshine/article/details/105113458 本文代码下载：https
Gabor滤波器特征提取原理讲解及c++实现
weixin_44901043的博客
03-19 6685
文章目录Gabor滤波器复正弦载波高斯滤波参数解释gabor滤波核实现效果： Gabor滤波器 1946年,Dennis Gabor于在“Theory of communication”一文中提出了著名的“窗口”傅里叶变换（也叫短时Fourier变换，STFT），即Gabor变换。 在图像处理邻域，Gabor小波是一种非常有效的纹理表示方法。 在空域，一个2维的Gabor滤波器是一个正弦平面波和高斯核函数的乘积： 其中s(x, y)是一个复正弦信号，称为载波，Wr(x, y)是一个二维信号高斯型函数，称
图像处理之Gabor滤波器（C++）
最新发布
qq_45045175的博客
04-13 744
Gabor滤波器是一个用于边缘提取的线性滤波器，其频率和方向表达与人类视觉系统类似，能够提供良好的方向选择和尺度选择特性，而且对于光照变化不敏感，十分适合纹理特征分析。本文介绍了Gabor原理以及C++实现的Gabor的过程。
C++实现gabor滤波
06-08
下面是一个简单的C++实现Gabor滤波器的示例代码： ```c++ #include #include #include using namespace cv; using namespace std; Mat gaborFilter(int kernelSize, double sigma, double theta, double ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值