C語言與Python的轉換

0 0

C語言與Python的轉換15

各位高手朋友您們好，最近要試著將尺度不變特徵轉換演算法〈SIFT，Scale-invariant feature transform〉以python實現，首先先請問各位有純python實現的完整程式碼可提供參考嗎？或者是麻煩您對以下我提出的幾段c程式碼片段，轉換成python寫法，麻煩您們了，不好意思。

(以下程式碼版權全部來自於http://blog.csdn.net/v_JULY_v)

主要對C語言的指標、結構、定義、opencv不太會轉換python，特來請教大家，請大家能夠盡量解答，若不方便的話，選擇幾段解答或者提供參考資料或網站也都可以，麻煩您們，萬分感謝。

//Data structure for a float image.
typedef struct ImageSt {        
 
 float levelsigma;
 int levelsigmalength;
 float absolute_sigma;
 CvMat *Level;       //CvMat是OPENCV的矩阵类，其元素可以是图像的象素值       
} ImageLevels;

typedef struct ImageSt1 {      
 int row, col;         
 float subsample;
 ImageLevels *Octave;              
} ImageOctaves;

ImageOctaves *DOGoctaves;      

  
ImageOctaves *mag_thresh ;
ImageOctaves *mag_pyr ;
ImageOctaves *grad_pyr ;


typedef struct KeypointSt 
{
 float row, col; 
 float sx,sy;    
 int octave,level;
 
 float scale, ori,mag; 
 float *descrip;       
 struct KeypointSt *next;
} *Keypoint;

//定义特征点具体变量
Keypoint keypoints=NULL;      
Keypoint keyDescriptors=NULL;

#define Im1Mat(ROW,COL) ((float *)(image1Mat->data.fl + image1Mat->step/sizeof(float) *(ROW)))[(COL)]
 
#define Im1G(ROW,COL) ((uchar*)(image1->imageData + image1->widthStep*(ROW)))[(COL)*3+1]
#define ImLevels(OCTAVE,LEVEL,ROW,COL) ((float *)(Gaussianpyr[(OCTAVE)].Octave[(LEVEL)].Level->data.fl + Gaussianpyr[(OCTAVE)].Octave[(LEVEL)].Level->step/sizeof(float) *(ROW)))[(COL)]
 
#define DST(ROW,COL) ((float *)(dst->data.fl + dst->step/sizeof(float) *(ROW)))[(COL)] 

#define Im(ROW,COL) ((float *)(im->data.fl + im->step/sizeof(float) *(ROW)))[(COL)]
#define Imnew(ROW,COL) ((float *)(imnew->data.fl + imnew->step/sizeof(float) *(ROW)))

for (int i=0; i<numoctaves;i++)
 {
  if (i==0)
  {
   mosaicHorizen1=MosaicHorizen( (Gaussianpyr[0].Octave)[0].Level, (Gaussianpyr[0].Octave)[1].Level );
   for (int j=2;j<SCALESPEROCTAVE+3;j++)
    mosaicHorizen1=MosaicHorizen( mosaicHorizen1, (Gaussianpyr[0].Octave)[j].Level );
   for ( j=0;j<NUMSIZE;j++)
    mosaicHorizen1=halfSizeImage(mosaicHorizen1);
  }
  else if (i==1)
  {
   mosaicHorizen2=MosaicHorizen( (Gaussianpyr[1].Octave)[0].Level, (Gaussianpyr[1].Octave)[1].Level );
   for (int j=2;j<SCALESPEROCTAVE+3;j++)
    mosaicHorizen2=MosaicHorizen( mosaicHorizen2, (Gaussianpyr[1].Octave)[j].Level );
   for ( j=0;j<NUMSIZE;j++)
    mosaicHorizen2=halfSizeImage(mosaicHorizen2);
   mosaicVertical1=MosaicVertical( mosaicHorizen1, mosaicHorizen2 );
  }
  else
  {
   mosaicHorizen1=MosaicHorizen( (Gaussianpyr[i].Octave)[0].Level, (Gaussianpyr[i].Octave)[1].Level );
   for (int j=2;j<SCALESPEROCTAVE+3;j++)
    mosaicHorizen1=MosaicHorizen( mosaicHorizen1, (Gaussianpyr[i].Octave)[j].Level );
   for ( j=0;j<NUMSIZE;j++)
    mosaicHorizen1=halfSizeImage(mosaicHorizen1);
   mosaicVertical1=MosaicVertical( mosaicVertical1, mosaicHorizen1 );
  }
 }
 mosaic1 = cvCreateImage(cvSize(mosaicVertical1->width, mosaicVertical1->height),  IPL_DEPTH_8U,1);
 cvConvertScale( mosaicVertical1, mosaicVertical1, 255.0, 0 );
 cvConvertScaleAbs( mosaicVertical1, mosaic1, 1, 0 );

for ( j = 0; j < h; j += 2)
  for ( i = 1; i < w - 1; i += 2)
   Imnew(j,i)=0.5*(Im(j/2, i/2)+Im(j/2, i/2+1));
  // interpolate pixels E and G
  for ( j = 1; j < h - 1; j += 2)
   for ( i = 0; i < w; i += 2)
    Imnew(j,i)=0.5*(Im(j/2, i/2)+Im(j/2+1, i/2));
   // interpolate pixel F
   for ( j = 1; j < h - 1; j += 2)
    for ( i = 1; i < w - 1; i += 2)
     Imnew(j,i)=0.25*(Im(j/2, i/2)+Im(j/2+1, i/2)+Im(j/2, i/2+1)+Im(j/2+1, i/2+1));
    return imnew;

for ( j = 0; j < src->rows; j++) 
 {
  for ( i = 0; i < src->cols; i++) 
  {
   //printf("%d, %d\n", i, j);
   DST(j,i) = ConvolveLocWidth(kern, dim, src, i, j);
  }
 }
}

octaves=(ImageOctaves*) malloc( numoctaves * sizeof(ImageOctaves) );
    DOGoctaves=(ImageOctaves*) malloc( numoctaves * sizeof(ImageOctaves) );
 
 printf("BuildGaussianOctaves(): Base image dimension is %dx%d\n", (int)(0.5*(image->cols)), (int)(0.5*(image->rows)) );
 printf("BuildGaussianOctaves(): Building %d octaves\n", numoctaves);
 
    // start with initial source image
 tempMat=cvCloneMat( image );
 // preblur_sigma = 1.0;//sqrt(2 - 4*INITSIGMA*INITSIGMA);
    initial_sigma = sqrt(2);//sqrt( (4*INITSIGMA*INITSIGMA) + preblur_sigma * preblur_sigma );
 //   initial_sigma = sqrt(SIGMA * SIGMA - INITSIGMA * INITSIGMA * 4);
    
 //在每一阶金字塔图像中建立不同的尺度图像
 for ( i = 0; i < numoctaves; i++) 
 {   
  //首先建立金字塔每一阶梯的最底层，其中0阶梯的最底层已经建立好
  printf("Building octave %d of dimesion (%d, %d)\n", i, tempMat->cols,tempMat->rows);
        //为各个阶梯分配内存
  octaves[i].Octave= (ImageLevels*) malloc( (SCALESPEROCTAVE + 3) * sizeof(ImageLevels) );
  DOGoctaves[i].Octave= (ImageLevels*) malloc( (SCALESPEROCTAVE + 2) * sizeof(ImageLevels) );
  //存储各个阶梯的最底层
  (octaves[i].Octave)[0].Level=tempMat;
  
  octaves[i].col=tempMat->cols;
  octaves[i].row=tempMat->rows;
  DOGoctaves[i].col=tempMat->cols;
  DOGoctaves[i].row=tempMat->rows;
  if (DOUBLE_BASE_IMAGE_SIZE)
            octaves[i].subsample=pow(2,i)*0.5;
  else
            octaves[i].subsample=pow(2,i);
  
  if(i==0)     
  {
   (octaves[0].Octave)[0].levelsigma = initial_sigma;
   (octaves[0].Octave)[0].absolute_sigma = initial_sigma;
   printf("0 scale and blur sigma : %f \n", (octaves[0].subsample) * ((octaves[0].Octave)[0].absolute_sigma));
  }
  else
  {
   (octaves[i].Octave)[0].levelsigma = (octaves[i-1].Octave)[SCALESPEROCTAVE].levelsigma;
            (octaves[i].Octave)[0].absolute_sigma = (octaves[i-1].Octave)[SCALESPEROCTAVE].absolute_sigma;
   printf( "0 scale and blur sigma : %f \n", ((octaves[i].Octave)[0].absolute_sigma) );
  }

(octaves[i].Octave)[j].levelsigma = sigma;
            (octaves[i].Octave)[j].absolute_sigma = absolute_sigma;
            //产生高斯层
   int length=BlurImage((octaves[i].Octave)[j-1].Level, dst, sigma_f);//相应尺度
            (octaves[i].Octave)[j].levelsigmalength = length;
   (octaves[i].Octave)[j].Level=dst;
            //产生DOG层
            cvSub( ((octaves[i].Octave)[j]).Level, ((octaves[i].Octave)[j-1]).Level, temp, 0 );
   //         cvAbsDiff( ((octaves[i].Octave)[j]).Level, ((octaves[i].Octave)[j-1]).Level, temp );
            ((DOGoctaves[i].Octave)[j-1]).Level=temp;
  }
  // halve the image size for next iteration
  tempMat  = halfSizeImage( ( (octaves[i].Octave)[SCALESPEROCTAVE].Level ) );


float Dxx,Dyy,Dxy,Tr_H,Det_H,curvature_ratio;
         Dxx = ImLevels(i,j,m,n-1) + ImLevels(i,j,m,n+1)-2.0*ImLevels(i,j,m,n);
         Dyy = ImLevels(i,j,m-1,n) + ImLevels(i,j,m+1,n)-2.0*ImLevels(i,j,m,n);
         Dxy = ImLevels(i,j,m-1,n-1) + ImLevels(i,j,m+1,n+1) - ImLevels(i,j,m+1,n-1) - ImLevels(i,j,m-1,n+1);

keypoint_count++;
          Keypoint k;
          /* Allocate memory for the keypoint. */
          k = (Keypoint) malloc(sizeof(struct KeypointSt));
          k->next = keypoints;
          keypoints = k;
          k->row = m*(GaussianPyr[i].subsample);
          k->col =n*(GaussianPyr[i].subsample);
          k->sy = m;    //行
          k->sx = n;    //列
          k->octave=i;
          k->level=j;
          k->scale = (GaussianPyr[i].Octave)[j].absolute_sigma;    


ORI(m,n) =atan( TEMPMAT2(m,n)/TEMPMAT1(m,n) );
                    if (ORI(m,n)==CV_PI)
      ORI(m,n)=-CV_PI;
    }
    ((mag_pyr[i].Octave)[j-1]).Level=Mag;
    ((grad_pyr[i].Octave)[j-1]).Level=Ori;

Keypoint p = keypoints; // p指向第一个结点
 
 while(p) // 没到表尾
 {
  int i=p->octave;
  int j=p->level;
  int m=p->sy;   //行
  int n=p->sx;   //列
  if ((m>=zero_pad)&&(m<GaussianPyr[i].row-zero_pad)&&
   (n>=zero_pad)&&(n<GaussianPyr[i].col-zero_pad) )
  {
   float sigma=( ((GaussianPyr[i].Octave)[j].absolute_sigma) ) / (GaussianPyr[i].subsample);
   //产生二维高斯模板
            CvMat* mat = GaussianKernel2D( sigma );         
   int dim=(int)(0.5 * (mat->rows));
   //分配用于存储Patch幅值和方向的空间
#define MAT(ROW,COL) ((float *)(mat->data.fl + mat->step/sizeof(float) *(ROW)))[(COL)]
   
   //声明方向直方图变量
   double* orienthist = (double *) malloc(36 * sizeof(double));
   for ( int sw = 0 ; sw < 36 ; ++sw) 
   {
    orienthist[sw]=0.0;  
   }
   //在特征点的周围统计梯度方向
            for (int x=m-dim,mm=0;x<=(m+dim);x++,mm++) 
    for(int y=n-dim,nn=0;y<=(n+dim);y++,nn++)
    {     
     //计算特征点处的幅值
     double dx = 0.5*(ImLevels(i,j,x,y+1)-ImLevels(i,j,x,y-1));  //dx
     double dy = 0.5*(ImLevels(i,j,x+1,y)-ImLevels(i,j,x-1,y));  //dy
     double mag = sqrt(dx*dx+dy*dy);  //mag
     //计算方向
     double Ori =atan( 1.0*dy/dx );
     int binIdx = FindClosestRotationBin(36, Ori);                   //得到离现有方向最近的直方块
     orienthist[binIdx] = orienthist[binIdx] + 1.0* mag * MAT(mm,nn);//利用高斯加权累加进直

sample12=getPixelBI(((GaussianPyr[p->octave].Octave)[p->level]).Level, x_sample, y_sample-1);

CvMat* MosaicVertical( CvMat* im1, CvMat* im2 )
{
 int row,col;
 CvMat *mosaic = cvCreateMat(im1->rows+im2->rows,max(im1->cols,im2->cols), CV_32FC1);
#define Mosaic(ROW,COL) ((float*)(mosaic->data.fl + mosaic->step/sizeof(float)*(ROW)))[(COL)]
#define Im11Mat(ROW,COL) ((float *)(im1->data.fl + im1->step/sizeof(float) *(ROW)))[(COL)]
#define Im22Mat(ROW,COL) ((float *)(im2->data.fl + im2->step/sizeof(float) *(ROW)))[(COL)]
 cvZero(mosaic);
 
 /* Copy images into mosaic1. */
 for ( row = 0; row < im1->rows; row++)
  for ( col = 0; col < im1->cols; col++)
   Mosaic(row,col)= Im11Mat(row,col) ;
  for ( row = 0; row < im2->rows; row++)
   for ( col = 0; col < im2->cols; col++)
    Mosaic((row+im1->rows),col)=Im22Mat(row,col) ;
   
   return mosaic;
}

问题补充：非常感謝您回應
但....有點不解
是利用C語言
的python.h
擴充python嗎
這樣django也可以利用到嗎
因主要還會用到django實現
方便 c程式轉換python幾段嗎謝謝您

woods 写道

http://www.google.com/codesearch?hl=en&lr=&q=Scale-invariant+feature+transform+python&sbtn=Search

Python