Zernike在1934年引入了一组定义在单位圆
上的复值函数集{
}，{
}具有完备性和正交性，使得它可以表示定义在单位圆盘内的任何平方可积函数。其定义为：
表示原点到点
的矢量长度；
表示矢量
与
轴逆时针方向的夹角。
是实值径向多项式：
称为Zernike多项式。
Zernike多项式满足正交性：
其中
为克罗内克符号，
是
的共轭多项式。
由于Zernike多项式的正交完备性，所以在单位圆内的任何图像
都可以唯一的用下面式子来展开：
式子中
就是Zernike矩，其定义为：
注意式子中
和
采用的是不同的坐标系（
采用直角坐标，而
采用的极坐标系，在计算的时候要进行坐标转换）
对于离散的数字图像，可将积分形式改为累加形式：
我们在计算一副图像的Zernike矩时，必须将图像的中心移到坐标的原点，将图像的像素点映射到单位圆内，由于Zernike矩具有旋转不变性，我们可以将
作为图像的不变特征，其中图像的低频特征有p值小的
提取，高频特征由p值高的
提取。从上面可以看出，Zernike矩可以构造任意高阶矩。
由于Zernike矩只具有旋转不变性，不具有平移和尺度不变性，所以要提前对图像进行归一化，我们采用标准矩的方法来归一化一副图像，标准矩定义为：
，
由标准矩我们可以得到图像的"重心"，
我们将图像的"重心"移动到单位圆的圆心（即坐标的原点），便解决了平移问题。
我们知道
表征了图像的"面积"，归一图像的尺度无非就是把他们的大小变为一致的，（这里的大小指的是图像目标物的大小，不是整幅图像的大小，"面积"也是目标物的"面积"）。
所以，对图像进行变换
就可以达到图像尺寸一致的目的。
综合上面结果，对图像进行
变换，最终图像
的Zernike矩就是平移，尺寸和旋转不变的。
Zernike 不变矩相比 Hu 不变矩识别效果会好一些，因为他描述了图像更多的细节内容，特别是高阶矩，但是由于Zernike 不变矩计算时间比较长，所以出现了很多快速的算法，大家可以 google 一下。
用 Zernike 不变矩来识别手势轮廓，识别率大约在 40%~50% 之间，跟 Hu 不变矩一样， Zernike 不变矩一般用来描述目标物形状占优势的图像，不适合用来描述纹理丰富的图像，对于纹理图像，识别率一般在 20%~30% 左右，很不占优势。
ZernikeMoment.h文件代码：
#pragma once
#include <iostream>
#include "opencv2/opencv.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
using namespace cv;
using namespace std;
#define MaxP(x,y) (float)(x>y?x:y)
#define MinP(x,y) (float)(x<y?x:y)
#define PI 3.14
typedef struct
{
float rou;
float sigma;
}
RS_POINT;
typedef struct
{
float x;
float y;
}CARTESIAN_POINT;
typedef struct
{
float r;
float t;
}POLAR_POINT;
typedef struct
{
float Cnm;
float Snm;
}ZERNIKE;
class ZernikeMoment{
private:
IplImage* oriImg;
IplImage* grayImg;
float Cnm,Snm;
float Z_mode;
public:
ZernikeMoment();
~ZernikeMoment();
float getRpqr(float p,float q,float r);
RS_POINT* get_rou_sigma(float x,float y);
CARTESIAN_POINT* get_x_y(float r,float s,int N);
int Img2Gray(void);
void ClearOpenCV(void);
float get_8_XYValue(int x,int y);
float get_32_XYValue(int x,int y);
float getZernike(int n,int m);
void Caculate_8_Zernike(int n,int m);
void Caculate_32_Zernike(int n,int m);
};
Zernike矩.cpp文件中的代码：
// ZernikeTest.cpp : 定义控制台应用程序的入口点。
/************************************************************
读入图像是在RGB2GRAY函数中，自己修改对应图像的路径
*************************************************************/
#include "stdafx.h"
#include <math.h>
#include "ZernikeMoment.h"
//#include "cv.h"
//#include "highgui.h"
//#include <opencv2/opencv.hpp>
#include <iostream>
using namespace std;
//using namespace cv;
double factorial(long n)//////////////
{
if(n < 0)
return(0.0) ;
if(n == 0)
return(1.0) ;
else
return(n * factorial(n-1)) ;
}
float zernikeR(int n, int l, float r)/////////////////
{
int m ;
float sum = 0.0 ;
if( ((n-l) % 2) != 0 )
{
cout <<"zernikeR(): improper values of n,l\n" ;
return(0) ;
}
for(m = 0; m <= (n-l)/2; m++)
{
sum += (pow((float)-1.0,(float)m)) * ( factorial(n-m) ) /
( factorial(m) * (factorial((n - 2*m + l) / 2)) *
(factorial((n - 2*m - l) / 2)) ) *
( pow((float)r, (float)(n - 2*m)) );
}
return(sum) ;
}
ZernikeMoment::ZernikeMoment()
{
oriImg = NULL;
grayImg = NULL;
Z_mode = 0;
}
ZernikeMoment::~ZernikeMoment()
{
}
//Fast Compute Zernike Polynomials Rpq(r)
float ZernikeMoment::getRpqr(float p,float q,float r)//////////////////////
{
/**** verify that p-q is even ***
**********************************/
float Rpqr = 0;
float Bppp=1;
int times = (p-q)/2;
int numbers = times+1;
float Bpqp = pow((p+q)/(p-q+2),times);
float* Bpqk = new float[numbers];
Bpqk[0] = Bpqp;
int k=(int)p;
int t=(int)p;
//Bpqk[0] is Bpqp , Bpqk[1] is Bpq(p-2) ... Bpqk[numbers-1] is Bpqq respectively
for(int i=0;i<(numbers-1);i++)
{
float coeff = ((k+q)*(k-q)) / ((k+p)*(p-k+2));
Bpqk[i+1] = (-1)*(Bpqk[i])*coeff;
k=k-2;
}
int temp = numbers-1;
//Compute Rpqr
for(k=(int)q;k<=t;k=k+2)
{
Rpqr = Rpqr + (Bpqk[temp])*(pow(r,k));
temp--;
}
delete[] Bpqk;
float a = Rpqr;
float b = Rpqr;
return Rpqr;
}
//Ordinary Compute Rpqr
//convert to rou, sigma coordinate,this function was never used.
RS_POINT* ZernikeMoment::get_rou_sigma(float x,float y)
{
RS_POINT *rs_p = new RS_POINT();
float rou = MaxP(abs(x),abs(y));
float sigma;
if(abs(x)==rou)
sigma = (2*(rou-x)*y)/abs(y)+x*y/rou;
if(abs(y)==rou)
sigma = 2*y -x*y/rou;
rs_p->rou = rou;
rs_p->sigma = sigma;
return rs_p;
}
//Convert rou-sigma to x-y coordinate,also never used.
CARTESIAN_POINT* ZernikeMoment::get_x_y(float rou,float sigma,int N)
{
float r = 2*rou/N;
float t = (PI*sigma)/4*rou;
CARTESIAN_POINT *xy_point = new CARTESIAN_POINT();
xy_point->x = r*cos(t);
xy_point->y = r*sin(t);
return xy_point;
}
//Get the x,y pixel value of Image ,8 depths
float ZernikeMoment::get_8_XYValue(int x,int y)//////////////////
{
int height = grayImg->height;
int widthStep = grayImg->widthStep;
char* Data = grayImg->imageData;
uchar c_value = ((uchar *)(Data+x*widthStep))[y];
float value = (float)c_value;
return value;
}
//Get the x,y pixel value of Image ,32 depths
float ZernikeMoment::get_32_XYValue(int x,int y)/////////////////
{
int height = grayImg->height;
int widthStep = grayImg->widthStep;
char* Data = grayImg->imageData;
float value = ((float *)(Data+x*widthStep))[y];
return value;
}
//RGB to Gray
//本函数部分代码被注释了，因为改为直接读入灰度图了
int ZernikeMoment::Img2Gray(void)/////////////
{
int a =1;
//if((oriImg = cvLoadImage("E:\\XH.jpg", 1)) != 0 )
if((grayImg = cvLoadImage("lena.jpg", 0)) != 0 )//读入一张灰度图
//if((grayImg = cvLoadImage("C:\\Users\\dell\\Desktop\\测试用图\\T5.bmp", 1)) != 0 )
{ //grayImg = cvCreateImage(cvSize(oriImg->width,oriImg->height),IPL_DEPTH_8U,1);
//cvCvtColor(oriImg,grayImg,CV_BGR2GRAY);
return 1;}
return 0;
}
//Cleanning Work,release memory,etc
void ZernikeMoment::ClearOpenCV(void)///////////////
{
if(oriImg!=NULL){
cvReleaseImage( &oriImg );
oriImg = NULL;
}
if(grayImg!=NULL){
cvReleaseImage( &grayImg );
grayImg = NULL;
}
}
//Function to caculate Zernike_8_(n,m), a very important function.
void ZernikeMoment::Caculate_8_Zernike(int n,int m)////////////////////
{
int height = grayImg->height;
int widthStep = grayImg->widthStep;
float N = MinP(height,widthStep);
float N2 = N/2;
float Rpqr_C =0;
float Rpqr_S =0;
for(float r=1;r<N2;r++)
{
float temp_C = 0;
float temp_S = 0;
for(float s=1;s<=8*r;s++)
{
float xy_v = get_8_XYValue(r,s);
temp_C = temp_C + cos((PI*m*s)/(4*r))*xy_v;
temp_S = temp_S + sin((PI*m*s)/(4*r))*xy_v;
}
//float Rpqr = getRpqr(n,m,(2*r)/N);
float Rpqr = zernikeR(n,m,(2*r)/N);
Rpqr_C =
Rpqr_C + temp_C* Rpqr;
Rpqr_S = Rpqr_S + temp_S* Rpqr;
}
Cnm = Rpqr_C*(2*n+2)/pow(N,2);
Snm = Rpqr_S*(2*n+2)/pow(N,2);
float l_c = pow(Cnm,2);
float l_s = pow(Cnm,2);
float l_p = l_c + l_s;
Z_mode = pow((float)l_p,(float)0.5);
}
//Function to caculate Zernike_32_(n,m), a very important function.
void ZernikeMoment::Caculate_32_Zernike(int n,int m)////////////
{
int height = grayImg->height;
int widthStep = grayImg->widthStep;
float N = MinP(height,widthStep);
float N2 = N/2;
float Rpqr_C =0;
float Rpqr_S =0;
for(float r=1;r<N2;r++)
{
float temp_C = 0;
float temp_S = 0;
for(float s=1;s<=8*r;s++)
{
float xy_v = get_32_XYValue(r,s);
temp_C+= cos((PI*m*s)/(4*r))*xy_v;
temp_S+= sin((PI*m*s)/(4*r))*xy_v;
}
float Rpqr = getRpqr(n,m,(2*r)/N);
Rpqr_C =
Rpqr_C + temp_C* Rpqr;
Rpqr_S = Rpqr_S + temp_S* Rpqr;
}
Cnm = Rpqr_C*(2*n+2)/pow(N,2);
Snm = Rpqr_S*(2*n+2)/pow(N,2);
Z_mode = pow((float)pow(Cnm,2)+pow(Cnm,2),(float)0.5);
}
float ZernikeMoment::getZernike(int n,int m)//////////////
{
int pass = Img2Gray();
if(!pass)
return -1;
int depth = 0;
int nChannels = 0;
nChannels = grayImg->nChannels;
// if(nChannels!=1)
// return -1;
depth = grayImg->depth;
switch(depth)
{
case IPL_DEPTH_8U: Caculate_8_Zernike(n,m); break;
case IPL_DEPTH_32F: Caculate_32_Zernike(n,m); break;
default: break;
}
ClearOpenCV();
return Z_mode;
}
int main( int argc, char** argv )
{
int succees = 0;
//Compute zernike modes ,for n = 4;
float *z_modes = new float[9];
ZernikeMoment *z_m = new ZernikeMoment();
int index = 0;
z_modes[index++] = z_m->getZernike(0,0);
z_modes[index++] = z_m->getZernike(1,1);
z_modes[index++] = z_m->getZernike(2,0);
z_modes[index++] = z_m->getZernike(2,2);
z_modes[index++] = z_m->getZernike(3,1);
z_modes[index++] = z_m->getZernike(3,3);
z_modes[index++] = z_m->getZernike(4,0);
z_modes[index++] = z_m->getZernike(4,2);
z_modes[index++] = z_m->getZernike(4,4);
if(z_m!=NULL)
delete z_m;
cout<<"zernike modes sequence: "<<endl;
for(int i=0;i<9;i++)
cout<<z_modes[i]<<",\n";//
cout<<endl;
return 0;
}
扫一扫
7224
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
