当前位置：编程学习 > Matlab >>

如何将以下程序改成能在matlab中运行？是matlab6.5的 邮箱280104434@qq.com

答案：BOOL CFunction::canny26(LPBYTE m_pDibData,CPoint ptLeft, CPoint ptRight , double sigma, double dRatLow, double dRatHigh) 
{ 
 BYTE* m_Newdata;//每一步处理后的图像数据
 m_Newdata = (BYTE*)malloc(maxImage);
 memcpy(m_Newdata,(BYTE *)m_pDibData,maxImage);

 //经过抑制局部像素非最大值的处理后的数据
    BYTE* pResult;//每一步处理后的图像数据
 pResult = (BYTE*)malloc(maxImage);
 memcpy(pResult,(BYTE *)m_pDibData,maxImage);
 int pointy,pointx,m,n,i=0;
 long Position; 
 int GradHori;
 int GradVert;
 //存储结构元素的数组
  BYTE array[9]={0};

 //设定两个阈值
 int nThrHigh,nThrLow; 

 //梯度分量 
 int gx; 
 int gy; 
 //中间变量 
 int g1,g2,g3,g4; 
 double weight; 
 double dTmp,dTmp1,dTmp2; 

 int Width,Higth;
 Width=ptRight.x-ptLeft.x+1;
  Higth=ptRight.y-ptLeft.y+1;
    CSize sz=CSize(Width,Higth);

 //x方向导数的指针 
 int *pGradX= new int[maxImage]; 
  memset(pGradX,0,maxImage);
 //y方向 
 int *pGradY; 
 pGradY = new int [maxImage];
  memset(pGradY,0,maxImage);
 //梯度的幅度 
 int *pGradMag; 
 pGradMag = new int [maxImage];
 //对pGradMag进行初始化
 for (pointy = 0;pointy <480;pointy++)
 {
  for (pointx = 0;pointx <640 ;pointx++)
   {
   Position=640 * (479 - pointy)+pointx;
            pGradMag[Position]=m_pDibData[Position];
  }
 }
               
//第一步进行高斯平滑器滤波
  //进入循环,使用3*3的结构元素，处理除去第一行和最后一行以及第一列和最后一列。
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
    Position=640 * (479 - pointy)+pointx;
    for (m = 0;m < 3;m++)
    {
     for (n = 0;n < 3;n++)
     {
      array[m*3+n]=m_pDibData[Position+640*(1-m)+n-1];  
     }
    }
    GradHori=abs(array[0]+2*array[1]+array[2]+2*array[3]+4*array[4]+2*array[5]+array[6]+2*array[7]+array[8]);
    GradHori=(int)(0.0625*GradHori+0.5);
    if (GradHori>255)
    {
     m_Newdata[Position]=255;
    }
    else
     m_Newdata[Position]=GradHori;
   }
  }
  
//第二步用一阶偏导的有限差分来计算梯度的幅值和方向
  //x方向的方向导数 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   { 
    pGradX[pointy*Width +pointx]=(int)(m_Newdata[pointy*Width +pointx+1]- m_Newdata[pointy*Width +pointx-1] ); 
   } 
  } 
  //y方向方向导数
  for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
  {
   for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
   {  
    pGradY[pointy*Width +pointx] = (int)(m_Newdata[(pointy+1)*Width +pointx] - m_Newdata[(pointy-1)*Width +pointx]); 
   } 
  } 
  //求梯度 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
    Position=640 * (479 - pointy)+pointx;
    for (m = 0;m < 3;m++)
    {
     for (n = 0;n < 3;n++)
     {
      array[m*3+n]=m_Newdata[Position+640*(1-m)+n-1];  
     }
    }
    GradHori=abs((-1)*array[0]+(-2)*array[3]+2*array[7]+array[8]);
    GradVert=abs((-1)*array[0]-2*array[1]+2*array[5]+array[8]);
             GradHori =(int)((float)sqrt(pow(GradHori,2)+pow(GradVert,2))+0.5);
    pGradMag[Position]=GradHori;
   }
  }
  //针对第一行的像素点及最后一行的像素点
  for (pointx = ptLeft.x;pointx <= ptRight.x;pointx++)
  {
   Position=640 * (479 - ptLeft.y)+pointx;
   pGradMag[Position]=0;
   Position=640 * (479 - ptRight.y)+pointx;
   pGradMag[Position]=0;
  }
  //针对第一列以及最后一列的像素点
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   Position=640 * (479 - pointy)+ptLeft.x;
   pGradMag[Position]=0;
   Position=640 * (479 - pointy)+ptRight.x;
   pGradMag[Position]=0;
  }

//第三步进行抑制梯度图中的非局部极值点的像素 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {  //当前点 
       Position=640 * (479 - pointy)+pointx;
   //如果当前像素梯度幅度为0，则不是边界点 
   if(pGradMag[Position] == 0) 
   { 
    pGradMag[Position] = 0; 
   } 
   else 
   { //当前点的梯度幅度 
    dTmp = pGradMag[Position];    
    //x,y方向导数 
    gx = pGradX[Position]; 
    gy = pGradY[Position]; 
    //如果方向导数y分量比x分量大，说明导数方向趋向于y分量 
    if(abs(gy) > abs(gx)) 
    { 
     //计算插值比例 
     weight = fabs(gx)/fabs(gy); 
     g2 = pGradMag[Position-640]; 
     g4 = pGradMag[Position+640]; 
     //如果x,y两个方向导数的符号相同 
     //C 为当前像素，与g1-g4 的位置关系为： 
     //g1 g2 
     //    C 
     //    g4 g3 
     if(gx*gy>0) 
     { 
      g1 = pGradMag[Position-640-1]; 
      g3 = pGradMag[Position+640+1]; 
     } 
     //如果x,y两个方向的方向导数方向相反 
     //C是当前像素，与g1-g4的关系为： 
     //     g2 g1 
     //     C 
     // g3 g4 
     else 
     { 
      g1 = pGradMag[Position-640+1]; 
      g3 = pGradMag[Position+640-1]; 
     } 
    } 
    //如果方向导数x分量比y分量大，说明导数的方向趋向于x分量 
    else    
    { 
     //插值比例 
     weight = fabs(gy)/fabs(gx); 
     g2 = pGradMag[Position+1]; 
     g4 = pGradMag[Position-1]; 
     //如果x,y两个方向的方向导数符号相同 
     //当前像素C与 g1-g4的关系为 
     // g3 
     // g4 C g2 
     //       g1 
     if(gx * gy > 0) 
     { 
      g1 = pGradMag[Position+640+1]; 
      g3 = pGradMag[Position-640-1]; 
     } 
     //如果x,y两个方向导数的方向相反 
     // C与g1-g4的关系为 
     //      g1 
     // g4 C g2 
     // g3 
     else 
     { 
      g1 =pGradMag[Position-640+1]; 
      g3 =pGradMag[Position+640-1]; 
     } 
    } 
    //利用 g1-g4 对梯度进行插值 
    { 
     dTmp1 = weight*g1 + (1-weight)*g2; 
     dTmp2 = weight*g3 + (1-weight)*g4; 
     //当前像素的梯度是局部的最大值 
     //该点可能是边界点 
     if(dTmp>=dTmp1 && dTmp>=dTmp2) 
     { 
      pResult[Position] = 128; 
     } 
     else 
     { 
      //不可能是边界点 
      pResult[Position] = 0; 
     } 
    } 
   } 
  } 
 } 

//第四步根据梯度计算及经过非最大值得印制后的结果设定阈值
  //估计TraceEdge 函数需要的低阈值，函数使用的高阈值 
  EstimateThreshold(pGradMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow); 
  //寻找大于dThrHigh的点，这些点用来当作边界点， 
  //然后用TraceEdge函数跟踪该点对应的边界 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   { 
    Position=640 * (479 - pointy)+pointx;
    //如果该像素是可能的边界点，并且梯度大于高阈值， 
    //该像素作为一个边界的起点 
    if((pResult[Position]==128) && (pGradMag[Position] >= nThrHigh)) 
    { 
     //设置该点为边界点 
     pResult[Position] = 255; 
%      
     TraceEdge(pointy,pointx,nThrLow,pResult,pGradMag,sz); 
    } 
   } 
  } 
  //其他点已经不可能为边界点 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
     Position=640 * (479 - pointy)+pointx;
    if(pResult[Position] != 255) 
    { 
     pResult[Position] = 0; 
    } 
   } 
 } 

 //计算方向导数和梯度的幅度 
//  Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag); 
 //应用非最大抑制 
// NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult); 
 //应用Hysteresis，找到所有边界 
// Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult);     
 memcpy(m_pDibData,(BYTE *)pResult,maxImage);
 delete[] pResult;
 pResult = NULL;
 delete[] pGradX; 
 pGradX = NULL; 
 delete[] pGradY; 
 pGradY = NULL; 
 delete[] pGradMag; 
 pGradMag = NULL; 
 delete[] m_Newdata; 
 m_Newdata = NULL; 
 return true;
}
其他：BOOL CFunction::canny26(LPBYTE m_pDibData,CPoint ptLeft, CPoint ptRight , double sigma, double dRatLow, double dRatHigh) 
{ 
 BYTE* m_Newdata;
 m_Newdata = (BYTE*)malloc(maxImage);
 memcpy(m_Newdata,(BYTE *)m_pDibData,maxImage);
BYTE* pResult;
 pResult = (BYTE*)malloc(maxImage);
 memcpy(pResult,(BYTE *)m_pDibData,maxImage);
 int pointy,pointx,m,n,i=0;
 long Position; 
 int GradHori;
 int GradVert;
  BYTE array[9]={0};
int nThrHigh,nThrLow; 
int gx; 
 int gy; 
 int g1,g2,g3,g4; 
 double weight; 
 double dTmp,dTmp1,dTmp2; 
 int Width,Higth;
 Width=ptRight.x-ptLeft.x+1;
  Higth=ptRight.y-ptLeft.y+1;
    CSize sz=CSize(Width,Higth);
 //x方向导数的指针 
 int *pGradX= new int[maxImage]; 
  memset(pGradX,0,maxImage);
 //y方向 
 int *pGradY; 
 pGradY = new int [maxImage];
  memset(pGradY,0,maxImage);
 //梯度的幅度 
 int *pGradMag; 
 pGradMag = new int [maxImage];
 //对pGradMag进行初始化
 for (pointy = 0;pointy <480;pointy++)
 {
  for (pointx = 0;pointx <640 ;pointx++)
   {
   Position=640 * (479 - pointy)+pointx;
            pGradMag[Position]=m_pDibData[Position];
  }
 }
               
//第一步进行高斯平滑器滤波
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
    Position=640 * (479 - pointy)+pointx;
    for (m = 0;m < 3;m++)
    {
     for (n = 0;n < 3;n++)
     {
      array[m*3+n]=m_pDibData[Position+640*(1-m)+n-1];  
     }
    }    GradHori=abs(array[0]+2*array[1]+array[2]+2*array[3]+4*array[4]+2*array[5]+array[6]+2*array[7]+array[8]);
    GradHori=(int)(0.0625*GradHori+0.5);
    if (GradHori>255)
    {
     m_Newdata[Position]=255;
    }
    else
     m_Newdata[Position]=GradHori;
   }
  }
  //第二步用一阶偏导的有限差分来计算梯度的幅值和方向
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   { 
    pGradX[pointy*Width +pointx]=(int)(m_Newdata[pointy*Width +pointx+1]- m_Newdata[pointy*Width +pointx-1] ); 
   } 
  } 
  for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
  {
   for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
   {  
    pGradY[pointy*Width +pointx] = (int)(m_Newdata[(pointy+1)*Width +pointx] - m_Newdata[(pointy-1)*Width +pointx]); 
   } 
  } 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
    Position=640 * (479 - pointy)+pointx;
    for (m = 0;m < 3;m++)
    {
     for (n = 0;n < 3;n++)
     {
      array[m*3+n]=m_Newdata[Position+640*(1-m)+n-1];  
     }
    }
    GradHori=abs((-1)*array[0]+(-2)*array[3]+2*array[7]+array[8]);
    GradVert=abs((-1)*array[0]-2*array[1]+2*array[5]+array[8]);
             GradHori =(int)((float)sqrt(pow(GradHori,2)+pow(GradVert,2))+0.5);
    pGradMag[Position]=GradHori;
   }
  }
  //针对第一行的像素点及最后一行的像素点
  for (pointx = ptLeft.x;pointx <= ptRight.x;pointx++)
  {
   Position=640 * (479 - ptLeft.y)+pointx;
   pGradMag[Position]=0;
   Position=640 * (479 - ptRight.y)+pointx;
   pGradMag[Position]=0;
  }
  //针对第一列以及最后一列的像素点
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   Position=640 * (479 - pointy)+ptLeft.x;
   pGradMag[Position]=0;
   Position=640 * (479 - pointy)+ptRight.x;
   pGradMag[Position]=0;
  }

//第三步进行抑制梯度图中的非局部极值点的像素 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {  
       Position=640 * (479 - pointy)+pointx;
   if(pGradMag[Position] == 0) 
   { 
    pGradMag[Position] = 0; 
   } 
   else 
   {  
    dTmp = pGradMag[Position];    
       gx = pGradX[Position]; 
    gy = pGradY[Position]; 
    //如果方向导数y分量比x分量大，说明导数方向趋向于y分量 
    if(abs(gy) > abs(gx)) 
    { 
     //计算插值比例 
     weight = fabs(gx)/fabs(gy); 
     g2 = pGradMag[Position-640]; 
     g4 = pGradMag[Position+640]; 
     if(gx*gy>0) 
     { 
      g1 = pGradMag[Position-640-1]; 
      g3 = pGradMag[Position+640+1]; 
     } 
     else 
     { 
      g1 = pGradMag[Position-640+1]; 
      g3 = pGradMag[Position+640-1]; 
     } 
    } 
    //如果方向导数x分量比y分量大，说明导数的方向趋向于x分量 
    else    
    { 
     //插值比例 
     weight = fabs(gy)/fabs(gx); 
     g2 = pGradMag[Position+1]; 
     g4 = pGradMag[Position-1]; 
     if(gx * gy > 0) 
     { 
      g1 = pGradMag[Position+640+1]; 
      g3 = pGradMag[Position-640-1]; 
     } 
     else 
     { 
      g1 =pGradMag[Position-640+1]; 
      g3 =pGradMag[Position+640-1]; 
     } 
    } 
    //利用 g1-g4 对梯度进行插值 
    { 
     dTmp1 = weight*g1 + (1-weight)*g2; 
     dTmp2 = weight*g3 + (1-weight)*g4; 
     //当前像素的梯度是局部的最大值 
     if(dTmp>=dTmp1 && dTmp>=dTmp2) 
     { 
      pResult[Position] = 128; 
     } 
     else 
     { 
      //不可能是边界点 
      pResult[Position] = 0; 
     } 
    } 
   } 
  } 
 } 

//第四步根据梯度计算及经过非最大值得印制后的结果设定阈值
  EstimateThreshold(pGradMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow); 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   { 
    Position=640 * (479 - pointy)+pointx;
    if((pResult[Position]==128) && (pGradMag[Position] >= nThrHigh)) 
    { 
     //设置该点为边界点 
     pResult[Position] = 255; 
%      
     TraceEdge(pointy,pointx,nThrLow,pResult,pGradMag,sz); 
    } 
   } 
  } 
  //其他点已经不可能为边界点 
  for (pointy = ptLeft.y+1;pointy <= ptRight.y-1;pointy++)
  {
   for (pointx = ptLeft.x+1;pointx <= ptRight.x-1;pointx++)
   {
     Position=640 * (479 - pointy)+pointx;
    if(pResult[Position] != 255) 
    { 
     pResult[Position] = 0; 
    } 
   } 
 } 

//  Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag); 
 //应用非最大抑制 
// NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult); 
 //应用Hysteresis，找到所有边界 
// Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult);     
 memcpy(m_pDibData,(BYTE *)pResult,maxImage);
 delete[] pResult;
 pResult = NULL;
 delete[] pGradX; 
 pGradX = NULL; 
 delete[] pGradY; 
 pGradY = NULL; 
 delete[] pGradMag; 
 pGradMag = NULL; 
 delete[] m_Newdata; 
 m_Newdata = NULL; 
 return true;
}

上一个：matlab的m文件中怎样改变文字大小
下一个：用matlab创建数列 an=n^4 1<=n<=50 跪求代码！急急急！！！！ 做出函数 f（x）=1/（1+x^3）的图像！！！！

更多图片编程知识:
更多Matlab疑问解答：
matlab中信噪比与误码率曲线
matlab的marker（比如"o"、"+"）怎样才能变粗一点呢？
用matlab编出大直径墩柱上不规则的波浪力程序
matlab语音识别系统设计中如何读取wav文件
matlab编程求助： R(1,1)=y*(p^2+x^2) 、R(1,2)=Y*(P*X)解方程组 结果得到的是含有R的表达式 而不是值
matlab 用后diff 数据长度变小 l
怎么在这段MATLAB程序导入的心电信号上添加一段50HZ的噪声？
matlab gui 清除图形
matlab在命令行中运行很好，存成m文件就不行，怎么办？
谁能帮我看下 这段程序到底哪出错了 关于Matlab牛顿环仿真的程序 高手救命啊
matlab 2011a 下好了 怎么安装啊 没有setup.exe
帮我看一下下面的matlab程序，运行时提示有错误，谢谢
matlab代码纠错
matlab中如何将若干个大小相等的二位数组存入三维矩阵中（不用嵌套循环）？
a(2:3,2:3)matlab元宝数组 这个是什么意思
asp
php
Delphi
Matlab
JSP
Foxpro
JS
C/C++
C#/ASP.NET
VC++
JAVA
VB
汇编语言
html/css
CGI
XML/UML
wap
网站相关
网页素材
python
如果你遇到编程学习难题：
请访问www.zzzyk.com 试试
CopyRight © 2012 站长网 编程知识问答 www.zzzyk.com All Rights Reserved
部份技术文章来自网络，