图像处理中的各种微分算子

最新推荐文章于 2024-01-20 19:54:11 发布
最新推荐文章于 2024-01-20 19:54:11 发布
阅读量668 收藏 2
点赞数 1
文章标签： 人工智能
原文链接：http://www.cnblogs.com/phquan/archive/2012/02/17/2356474.html
版权

         微分算子在图像处理中扮演重要的角色，其算法实现简单，而且边缘检测的效果又较好，因此这些基本的微分算子是学习图像处理过程中的必备方法，下面着重讨论几种常见的微分算子。 

1.Sobel

       其主要用于边缘检测，在技术上它是以离散型的差分算子，用来运算图像亮度函数的梯度的近似值，缺点是Sobel算子并没有将图像的主题与背景严格地区分开来，换言之就是Sobel算子并没有基于图像灰度进行处理，由于Sobel算子并没有严格地模拟人的视觉生理特征，所以提取的图像轮廓有时并不能令人满意，算法具体实现很简单，就是3*3的两个不同方向上的模板运算，这里不再写出。

2.Robert算子

       根据任一相互垂直方向上的差分都用来估计梯度，Robert算子采用对角方向相邻像素只差

3.Prewitt算子

       该算子与Sobel算子类似，只是权值有所变化，但两者实现起来功能还是有差距的，据经验得知Sobel要比Prewitt更能准确检测图像边缘。

4.Laplacian算子

       拉普拉斯算子是一种二阶微分算子，若只考虑边缘点的位置而不考虑周围的灰度差时可用该算子进行检测。对于阶跃状边缘，其二阶导数在边缘点出现零交叉，并且边缘点两旁的像素的二阶导数异号。

5.Canny算子

        该算子功能比前面几种都要好，但是它实现起来较为麻烦，Canny算子是一个具有滤波，增强，检测的多阶段的优化算子，在进行处理前，Canny算子先利用高斯平滑滤波器来平滑图像以除去噪声，Canny分割算法采用一阶偏导的有限差分来计算梯度幅值和方向，在处理过程中，Canny算子还将经过一个非极大值抑制的过程，最后Canny算子还采用两个阈值来连接边缘。

     下面算法是基于的算法不可能直接运行，只是我把Canny的具体实现步骤写了出来，若需用还要自己写。

 

该算子具体实现方法：

 

// anny.cpp: implementation of the Canny class.
 
//
 
//
 
 
 
#include "anny.h"
 
#include "math.h"
 
//#include "algorithms.h"
 
//#include "algorithm.h"
 
#include "stdlib.h"
 
//#include "maths.h"
 
//using namespace std;
 
//
 
// Construction/Destruction
 
//
 
 
 
Canny::Canny(int PicHeight,int PicWidth,double ** PicData,double PicSigma,double  PicRatioLow,double PicRatioHigh)
 
{
 
 iHeight=PicHeight;
 
 iWidth=PicWidth;
 
 iData=PicData;
 
 sigma=PicSigma;
 
 dRatioLow=PicRatioLow;
 
 dRatioHigh=PicRatioHigh;
 
}
 
Canny::~Canny()
 
{
 
}
 
void Canny::CannyArith(int **iEdgePoint)
 
{
 
 int i;
 
 int **iGradX ;                       // 指向x方向导数的指针
 
    int **iGradY ;                         // 指向y方向导数的指针
 
    int **iExtent ;                      // 梯度的幅度
 
 iGradX=new int *[iHeight];
 
 for(i=0;i<iHeight;i++) 
 
  iGradX[i]=new int[iWidth];
 
 iGradY=new int *[iHeight];
 
 for(i=0;i<iHeight;i++) 
 
  iGradY[i]=new int[iWidth];
 
 iExtent=new int *[iHeight];
 
 for(i=0;i<iHeight;i++) 
 
  iExtent[i]=new int[iWidth];
 
 // 对原图象进行滤波
 
         GaussionSmooth();
 
// 计算X,Y方向上的方向导数
 
    DirGrad(iGradX,iGradY); 
 
    // 计算梯度的幅度
 
    GradExtent(iGradX,iGradY,iExtent);
 
    // 应用non-maximum 抑制
 
   NonMaxSuppress(iExtent,iGradX,iGradY,iEdgePoint);
 
 // 应用Hysteresis，找到所有的边界
 
    Hysteresis(iExtent,iEdgePoint);
 
 // 释放内存
 
 for(i=0;i<iHeight;i++)  
 
        delete  []*(iGradX+i);  
 
    delete   iGradX;
 
 for(i=0;i<iHeight;i++)  
 
        delete  []*(iGradY+i);  
 
    delete   iGradY;
 
 for(i=0;i<iHeight;i++)  
 
        delete  []*(iExtent+i);  
 
    delete   iExtent; 
 
}
 
void Canny::GaussionSmooth()
 
{
 
 int i,j,k;                             //循环变量
 
 int iWindowSize;                       //记录模板大小的变量
 
 int iHalfLen;                          //模板大小的一半
 
 double *pdKernel;                         //模板各点的权值
 
 double dDotMul;                        //模板与对应像素点的卷积和
 
 double dWeightSum;                     //模板的权值累加和
 
 double **dTemp;                         //记录图像数据的中间变量
 
 //开辟空间
 
 dTemp=new double *[iHeight];           
 
 for(i=0;i<iHeight;i++)
 
  dTemp[i]=new double[iWidth];
 
 //获得模板长度和模板的各个权值
 
 MakeGauss(&pdKernel,&iWindowSize);
 
 //得到模板的一半长度
 
 iHalfLen=iWindowSize/2;
 
 //对图像对水方向根据模板进行平滑
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
   dDotMul=0;
 
   dWeightSum=0;
 
   for(k=(-iHalfLen);k<=iHalfLen;k++)
 
   {
 
    if((k+j>=0)&&(k+j<iWidth))
 
    {
 
     dDotMul+=iData[i][j+k]*pdKernel[k+iHalfLen];
 
     dWeightSum+=pdKernel[k+iHalfLen];
 
    }
 
   }
 
   dTemp[i][j]=dDotMul/dWeightSum;
 
  }
 
 }
 
 //对图像垂直方向上根据模板的转置进行平滑(注意图像数据是在水平平滑之后进行的)
 
 for(i=0;i<iWidth;i++)
 
 {
 
  for(j=0;j<iHeight;j++)
 
  {
 
   dDotMul=0;
 
   dWeightSum=0;
 
   for(k=(-iHalfLen);k<=iHalfLen;k++)
 
   {
 
    if((k+j>=0)&&(k+j<iHeight))
 
    {
 
     dDotMul+=dTemp[j+k][i]*pdKernel[k+iHalfLen];
 
     dWeightSum+=pdKernel[k+iHalfLen];
 
    }
 
   }
 
   iData[j][i]=dDotMul/dWeightSum;
 
  }
 
 }
 
 //空间释放
 
    delete []pdKernel;
 
 pdKernel=NULL;
 
 for(i=0;i<iHeight;i++)  
 
        delete  []*(dTemp+i);  
 
    delete   dTemp;  
 
}
 
 
 
void Canny::MakeGauss(double **pdKernel,int *iWindowSize)
 
{
 
 int i;                             //循环变量
 
 int nCenter;                       //确定高斯模板的一半长度
 
 double dDistance;                  //一维高斯模板各点离中心点的距离
 
 double PI=3.1415926;               //圆周率              
 
 double dValue;                     //中间变量，记录高斯模板各点的权值(未经归一化)
 
 double dSum=0;                     //中间变量，记录高斯模板各点权值的总和
 
 *iWindowSize=int(1+2*int(3*sigma+0.5));    //确定一维高斯模板长度，根据概率论的知识，选取[-3*sigma, 3*sigma]以内的数据。
 
 nCenter=(*iWindowSize)/2;          //得到一半长度
 
 *pdKernel=new double[*iWindowSize];//开辟记录各点权值的空间
 
 //利用高斯分布函数(正太分布)确定各点的权值，主要是根据高斯分布离中心点的距离越远，所取的值就越小，这与图像有些
 
 //相似，离中心点越远，对中心点的影响就越小。
 
 for(i=0;i<(*iWindowSize);i++)
 
 {
 
  dDistance=double(i-nCenter);
 
  //高斯分布函数求值
 
  dValue=exp((-1/2)*dDistance*dDistance/(sigma*sigma))/(sqrt(2*PI)*sigma);
 
  (*pdKernel)[i]=dValue;
 
  dSum+=dValue;
 
 }
 
 //归一化(因为要不改变原图像的灰度区域，就必须保证各权值之和为1
 
 for(i=0;i<(*iWindowSize);i++)
 
 {
 
  (*pdKernel)[i] /= dSum;
 
 }
 
}
 
void Canny::DirGrad(int **iGradX,int **iGradY)
 
{
 
 int i,j,temp1,temp2;
 
 //水平方向的方向导数(下面都是用min和max对边界值做了相应的处理)
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
 
 
   if(iWidth-1<j+1)
 
    temp1=iWidth-1;
 
   else
 
    temp1=j+1;
 
   if(0<j-1)
 
    temp2=j-1;
 
   else
 
    temp2=0;
 
   iGradX[i][j]=int(iData[i][temp1]-iData[i][temp2]);
 
  }
 
 }
 
 //垂直方向的方向导数
 
 for(i=0;i<iWidth;i++)
 
 {
 
  for(j=0;j<iHeight;j++)
 
  {
 
   if(iHeight-1<j+1)
 
    temp1=iHeight-1;
 
   else
 
    temp1=j+1;
 
   if(0<j-1)
 
    temp2=j-1;
 
   else
 
    temp2=0;
 
   iGradY[j][i]=int(iData[temp1][i]-iData[temp2][i]);
 
  }
 
 }
 
}
 
void Canny::GradExtent(int **iGradX,int **iGradY,int **iExtent)
 
{
 
 int i,j;
 
 double iTemp1,iTemp2;
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
   iTemp1=iGradX[i][j]*iGradX[i][j];
 
   iTemp2=iGradY[i][j]*iGradY[i][j];
 
   iExtent[i][j]=int(sqrt(iTemp1+iTemp2)+0.5);
 
  }
 
 }
 
}
 
void Canny::NonMaxSuppress(int **iExtent,int **iGradX,int **iGradY,int **dUnchRst)
 
{
 
 int i,j;
 
 int gx,gy;                     //记录像素点X,Y 方向的方向导数值
 
 int g1,g2,g3,g4;               //各个领域的梯度值
 
 double weight;                    //比重
 
 double dTemp1,dTemp2,dTemp;       //中间变量
 
 //处理边缘值(边缘点不可能是边界点
 
  for(i=0;i<iHeight;i++)
 
 {
 
  dUnchRst[i][0]=0;
 
  dUnchRst[i][iWidth-1]=0;
 
 }
 
 for(j=0;j<iWidth;j++)
 
 {
 
  dUnchRst[0][j]=0;
 
  dUnchRst[iHeight-1][j]=0;
 
 }
 
 //标记有可能是边界点的像素点
 
 for(i=1;i<iHeight-1;i++)
 
 {
 
  for(j=1;j<iWidth-1;j++)
 
  {
 
   //梯度值是0的像素点不可能是边界点
 
   if(iExtent[i][j]==0)
 
    dUnchRst[i][j]=0;
 
   else
 
   {
 
    dTemp=iExtent[i][j];
 
    gx=iGradX[i][j];
 
    gy=iGradY[i][j];
 
    //下面都是判断当前像素点的梯度值和其领域像素点的梯度值，如大于就有可能是边界点，如小于就不可能是边界点
 
    if(abs(gy)>abs(gx))
 
    {
 
         weight=double(abs(gx)/abs(gy));
 
        g2=iExtent[i-1][j];
 
        g4=iExtent[i+1][j];
 
        if(gx*gy>0)
 
        {
 
         g1=iExtent[i-1][j-1];
 
         g3=iExtent[i+1][j+1];
 
        }
 
        else
 
        {
 
         g1=iExtent[i-1][j+1];
 
         g3=iExtent[i+1][j-1];
 
        }
 
    }
 
    else
 
    {
 
     weight=double(abs(gy)/abs(gx));
 
     g2=iExtent[i][j+1];
 
     g4=iExtent[i][j-1];
 
     if(gx*gy>0)
 
     {
 
      g1=iExtent[i+1][j+1];
 
      g3=iExtent[i-1][j-1];
 
     }
 
     else
 
     {
 
      g1=iExtent[i-1][j+1];
 
      g3=iExtent[i+1][j-1];
 
     }
 
    }
 
    dTemp1=weight*g1+(1-weight)*g2;
 
    dTemp2=weight*g3+(1-weight)*g4;
 
    //当大于的时候就有可能是边界点
 
    if(dTemp>=dTemp1&&dTemp>=dTemp2)
 
    {
 
     dUnchRst[i][j] = 128 ;
 
    }
 
    else
 
    {
 
     dUnchRst[i][j]=0 ;
 
    }
 
   }
 
 
 
  } 
 
 }
 
}
 
void Canny::Hysteresis(int **iExtent,int **iEdgePoint)
 
{
 
 int i,j;
 
 int iThreHigh;
 
 int iThreLow;
 
 SetThreshold(iExtent,&iThreHigh,&iThreLow,iEdgePoint);
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
   if((iEdgePoint[i][j]==128)&&(iExtent[i][j]>=iThreHigh))
 
   {
 
    iEdgePoint[i][j]=255;
 
    TraceEdge(i,j,iThreLow,iEdgePoint,iExtent);
 
   }
 
  }
 
 }
 
 // 那些还没有被设置为边界点的象素已经不可能成为边界点
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
   
 
   if(iEdgePoint[i][j]!=255)
 
   {
 
    // 设置为非边界点
 
    iEdgePoint[i][j] = 0 ;
 
   }
 
  }
 
  }
 
 
 
}
 
void Canny::SetThreshold(int **iExtent,int *iThreHigh,int *iThreLow,int **iEdgePoint)
 
{
 
 int i,j,k;
 
 int GradHist[1024];                     //统计梯度直方图的数据，梯度最大值不可能超过1024
 
 int iEdgeNum;                           //边界点的数量
 
 int iGradMax=0;                         //边界点的梯度最大值
 
 int iHighCount;                         //根据iRatioHigh小于高阈值像素的个数
 
 //初始化
 
 for(i=0;i<1024;i++)
 
  GradHist[i]=0;
 
 //梯度直方图统计
 
 for(i=0;i<iHeight;i++)
 
 {
 
  for(j=0;j<iWidth;j++)
 
  {
 
   if(iEdgePoint[i][j]==128)
 
   {
 
    GradHist[iExtent[i][j]]++;
 
   }
 
  }
 
 }
 
 iEdgeNum=0;
 
 //找出最大梯度和统计边界点的个数
 
 for(i=0;i<1024;i++)
 
 {
 
  if(GradHist[i]!=0)
 
   iGradMax=i;
 
  iEdgeNum+=GradHist[i];
 
 }
 
 //获得小于高阈值的个数
 
 iHighCount=int(iEdgeNum*dRatioHigh+0.5);
 
 k=1;
 
 iEdgeNum=GradHist[1];
 
 //求出高阈值
 
 while((k<=(iGradMax-1))&&(iEdgeNum<iHighCount))
 
 {
 
  k++;
 
  iEdgeNum+=GradHist[k];
 
 }
 
 *iThreHigh=k;
 
 //根据高阈值和比例关系求得低阈值
 
 *iThreLow=int((*iThreHigh)*dRatioLow+0.5);
 
 
 
}
 
void Canny::TraceEdge(int y,int x,int iThreLow,int **iEdgePoint,int **iExtent)
 
{
 
 // 对8邻域象素进行查询
 
 int xNb[8] = {1, 1, 0,-1,-1,-1, 0, 1} ;
 
 int yNb[8] = {0, 1, 1, 1,0 ,-1,-1,-1} ;
 
 int yy ;
 
 int xx ;
 
 int k  ;
 
 for(k=0;k<8;k++)
 
 {
 
  yy=y+yNb[k] ;
 
  xx=x+xNb[k] ;
 
 // 如果该象素为可能的边界点，又没有处理过, 并且梯度大于阈值
 
  if(iEdgePoint[yy][xx]==128&&iExtent[yy][xx]>=iThreLow)
 
  {
 
 // 把该点设置成为边界点
 
  iEdgePoint[yy][xx]=255 ;
 
 // 以该点为中心进行跟踪
 
      //TraceEdge(yy,xx,iThreLow,iEdgePoint,iExtent);
 
 
 
  }
 
 }
 
}

 

　　

转载于:https://www.cnblogs.com/phquan/archive/2012/02/17/2356474.html

weixin_30349597
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
偏微分方程图像处理序列——连续算子和离散算子对应
hit1524468的专栏
09-28 1654
偏微分方程图像处理
图像处理 -----图像微分知识（1、2阶导数和拉普拉斯算子）
yerunting的博客
10-07 760
添加链接描述
微分,泰勒公式及其在图像处理中的应用
视觉小新的博客
02-24 1347
前段时间，看图像处理和机器学习的时候，遇到了高数中微分与积分的内容，就复习了一下相关内容，下面就是这几天学习的一个笔记，因为我不是学数学的，数学基础也不好，相关概念理解可能不够准确，甚至有错误，欢迎大家批评指正。 微分 起源 微分概念是在解决直与曲的矛盾中产生的，在微小局部是否可以使用用直线去近似替代曲线？(这个思想就是后来微积分中著名的”以直代曲”思想)。  如果在这个微小的局部，函数的增量可...
【C++】图像处理中的微分算子原理与实现
weixin_45355387的博客
08-19 3404
图像处理中的微分算子原理与实现 一阶微分边缘算子：经典算子比如：Roberts(罗伯特)、Prewitt（普鲁伊特）、Sobel(索贝尔)，Canny（坎尼）等。 二阶微分边缘算子：Laplacian算子，LoG（ Laplace of Gaussian function）边缘检测算子和DoG（Difference of Gaussian）高斯差分算子。 Roberts算子 1963年，Roberts算子，又称罗伯茨算子，是一种最简单的算子，是一种利用局部差分算子寻找边缘的算子。他采用对角线方向相
微分算子法
最新发布
2302_78846666的博客
01-20 519
总结，微分算子法是一个求微分方程特解的好方法，可以在掌握求解微分方程基本方法的同时，学一下这个方法，对自身有很好的帮助。
作业5程永鑫21934169_数字图像处理matlab_一阶微分锐化_
09-29
总之，数字图像处理中的锐化和滤波技术是至关重要的，它们可以帮助我们改善图像质量，突出关键特征。MATLAB作为一种强大的工具，提供了丰富的函数和工具箱，使得这些操作变得简单易行。通过学习和实践，我们可以掌握...
图像处理_拉普拉斯算子_fly96z_图像处理matlab_
09-29
在图像处理领域，拉普拉斯算子是一种广泛使用的边缘检测算子，它是基于图像梯度的一种二阶微分算子。本项目由fly96z提供，主要关注使用MATLAB进行图像处理，包括了多种边缘检测算法的实现，如Sobel、Prewitt、...
图像处理的偏微分方程方法全书代码
10-31
《图像处理的偏微分方程方法全书代码》是一本深入探讨图像处理技术的专著，其核心在于利用偏微分方程（PDEs）来解决图像处理中的各种问题。偏微分方程在图像处理领域具有广泛应用，因为它们能够有效地模拟图像的连续...
数字图像处理中边缘检测算子优缺点探讨.docx
02-20
【图像边缘检测】在数字图像处理中，边缘检测是一项关键技术，它有助于识别图像中的目标物体，揭示图像的结构信息。图像边缘是图像局部特性不连续的体现，标记着图像区域的过渡，对于图像分割、纹理分析、形状特征...
一阶微分图像锐化（梯度幅值）.pdf
03-20
该文档说明了一阶微分图像锐化的原理。通过阅读冈萨雷斯的数字图像处理第三版中的相关章节，总结了一阶微分图像锐化的原理。
微分算子求解微分方程
weixin_30666943的博客
01-21 790
n阶常系数非齐次线性微分方程： $$ y ^ { ( n ) } + p _ { 1 } y ^ { ( n - 1 ) } + p _ { 2 } y ^ { ( n - 2 ) } + .... + p _ { n - 1 } y ^ { \prime } + p _ { n } y = f ( x ) \neq 0 $$ 记号： $$\frac { d } { d x } = D , ...
微分算子法总结
热门推荐
wwxy1995的博客
08-27 4万+
强行假设D是可逆的， Dx^3 = 3x^2 -> x^3 = D^(-1）*(3x^2) , 所以1/D表示积分 注意到D(exp(ax)) = aD(exp(ax)) ， 所以exp(ax)是D的特征向量，a是特征值，根据特征值的性质，有如下性质 这个定理的证明 D(exp(ax)v(x)) = Dv(x) exp(ax) + D(v(x)) a(exp(ax...
微分算子法个人整理
SoKeeGan
12-02 4971
陈文灯老师创立的微分算子法，在求解特定的微分方程能够省去大部分的计算时间。 很久不写了，这篇为了回顾方便。 一同有四种总结 感谢B站BV1D5411776Q的总结！ 考研加油！稳定发挥！
并行边缘检测 - 一阶微分算子
奔跑的皮卡丘
11-13 2244
基本原理一阶微分算子（即梯度算子）利用灰度一阶导数的信息完成幅图像边缘的检测。代表Roberts，Kirsch，Prewitt，Sobel，Isotropic Sobel，Robinson，Frei，Chen等。计算一阶梯度，选取阀值，灰度梯度幅值大于阀值处点作为阶跃状边缘点检出。计算幅值常用近似方法： |∇f|=|Gx|+|Gy||\nabla f|=|G_x|+|G_y| |∇f|=max(
10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、Prewitt算子、高斯拉普拉斯算子
集电极
08-27 1万+
10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、Prewitt算子、高斯拉普拉斯算子 文章目录10.1 Python图像处理之边缘算子-Sobel算子、Roberts算子、拉普拉斯算子、Canny算子、Prewitt算子、高斯拉普拉斯算子1 算法原理1.1 Sobel 算子1.2 Roberts 算子1.3 拉普拉斯(Laplacian) 算子1.4 Canny 算法1.5 Prewitt 算子1.6 高斯拉普拉斯算子（LOG 算子）2 代码3 效
图像处理中的微分算子
q15516221118的博客
02-01 3346
微分算子在图像处理中的作用主要是用在图像的边缘检测，而图像边缘检测必须满足两个条件：一能有效的抑制噪声，二能必须尽量精确定位边缘位置。现在常用的微分算子主要有：Sobel算子，Robert算子，Prewitt算子，拉氏算子，Canny算子，下面通过这两个必须满足的条件对这几种算子的性能进行分析。
数字图像处理：（2）一阶微分和二阶微分在数字图像处理中的应用
m0_37957160的博客
07-29 4053
1、微分定义 2、微分性质 微分是对函数局部变化率的一种表示。 在图像处理中有基于一阶微分和二阶微分的锐化空间滤波器(图像锐化是增强图像的突变部分)，其实一阶微分和二阶微分算子都可以得到图像的边缘，只是效果不一样。 一阶微分的性质： （1）在恒定的灰度区域，图像的微分值为0.（灰度值没有发生变换，自然微分为0） （2）在灰度台阶或斜坡起点处微分值不为0.（台阶是，灰度值的突变变化较大；斜坡则是灰度值变化较缓慢；灰度值发生了变化，微分值不为0） （3）沿着斜坡的微分值不为0. 使用..
数字图像处理：（3）一阶微分算子在图像处理中的应用
m0_37957160的博客
07-30 4167
1、数学基础 函数一阶导数对应的微分称为一阶微分; 一阶微分的微分称为二阶微分; 二阶微分及以上的微分称为高阶微分； 首先，图像是离散的数据，若求其导数就要用差分的方法，常用的差分方法是前向差分（forward differencing）与中心差分（central differencing）。一阶导本质上求的是斜率，二阶导求的是拐点。 2、图像微分知识： 一阶导数： 图像梯度： 二阶导数： 3、滤波器 平滑滤波器（低通滤波器），是用来平滑图像和抑制噪声的；而锐化空间滤...
图像处理之一阶微分应用
web开发
05-13 630
图像处理之一阶微分应用 一：数学背景 首先看一下一维的微分公式Δf = f(x+1) – f(x), 对于一幅二维的数字图像f(x,y)而言，需要完 成XY两个方向上的微分，所以有如下的公式： 分别对X,Y两个方向上求出它们的偏微分，最终得到梯度Delta F. 对于离散的图像来说,一阶微分的数学表达相当于两个相邻像素的差值，根据选择的梯度算 子不同，效果可能有所不同，但是基本原理...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值