所以按照梯度的要求 假设y=y（x） 即y（x）-y=0 那么梯度为 （y’，-1）
由于y’=(dy/dt) /(dx/dt)
求得梯度为（(dy/dt) /(dx/dt)，-1）或者（(dy/dt)，-(dx/dt)）
三维的类推
梯度grad(f)=(fx,fy,fz)=fx·i+fy·j+fz·k(fx表示f关于x的偏导)。
则rota=(δfz/δy-δfy/δz)i+(δfx/δz-δfz/δx)j+(δfy/δx-δfx/δy)k，δfz/δy-δfy/δz=fzy-fyz=0，δfx/δz-δfz/δx=fxz-fzx=0，δfy/δx-δfx/δy=fyx-fxy=0（δ为偏导的符号）。梯度，散度，旋度，是微积分最后的内容了，主要要熟练它们的定义。
相关介绍：
高数（Higher Mathematics），又称高等数学，是比初等数学更高深的数学，是理、工科院校一门重要的基础学科，该课程的主要内容有，极限理论、常微分方程、多元微积分学与空间解析几何等，在其教材中，以微积分学和级数理论为主体，其他方面的内容为辅，各类课本略有差异。
学习高数有利于培养学生的运算能力、抽象思维及逻辑推理等能力，从而使学生有更强的解决实际问题的能力。
反向传播梯度为0说明参数在本次微调时不需要调整。也就是说，在使用反向传播进行参数更新时，某个参数的梯度为0，表明其在本次更新中不会发生变化。反向传播梯度为0的出现一般有两种情况：一种是梯度下降算法在某个参数处发现了局部最优点，另一种是参数的梯度在接近0的范围内波动，使得梯度下降算法无法继续更新该参数。
一般情况下，当反向传播梯度为0时，参数不会发生变化，但也不能断定这个参数完全没有变化，因为反向传播梯度为0只是暂时的，可能会在后面的反向传播步骤中发生变化，此时可以考虑使用其他优化算法来调整参数，以达到更好的性能。Matlab上有CANNY算子的库函数啊，直接调用就行了。
我这有VC++的边缘检测算法，很长的。稍微改一下就可以用在Matlab上。
/ 一维高斯分布函数，用于平滑函数中生成的高斯滤波系数
void CFunction::CreatGauss(double sigma, double pdKernel, int pnWidowSize)
{
LONG i;
//数组中心点
int nCenter;
//数组中一点到中心点距离
double dDis;
//中间变量
double dValue;
double dSum;
dSum = 0;
// [-3sigma,3sigma] 以内数据，会覆盖绝大部分滤波系数
pnWidowSize = 1+ 2ceil(3sigma);
nCenter = (pnWidowSize)/2;
pdKernel = new double[pnWidowSize];
//生成高斯数据
for(i=0;i<(pnWidowSize);i++)
{
dDis = (double)(i - nCenter);
dValue = exp(-(1/2)dDisdDis/(sigmasigma))/(sqrt(231415926)sigma);
(pdKernel)[i] = dValue;
dSum+=dValue;
}
//归一化
for(i=0;i<(pnWidowSize);i++)
{
(pdKernel)[i]/=dSum;
}
}
//用高斯滤波器平滑原图像
void CFunction::GaussianSmooth(SIZE sz, LPBYTE pGray, LPBYTE pResult, double sigma)
{
LONG x, y;
LONG i;
//高斯滤波器长度
int nWindowSize;
//窗口长度
int nLen;
//一维高斯滤波器
double pdKernel;
//高斯系数与图像数据的点乘
double dDotMul;
//滤波系数总和
double dWeightSum;
double pdTemp;
pdTemp = new double[szcxszcy];
//产生一维高斯数据
CreatGauss(sigma, &pdKernel, &nWindowSize);
nLen = nWindowSize/2;
//x方向滤波
for(y=0;y<szcy;y++)
{
for(x=0;x<szcx;x++)
{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
//判断是否在图像内部
if((i+x)>=0 && (i+x)<szcx)
{
dDotMul+=(double)pGray[yszcx+(i+x)] pdKernel[nLen+i];
dWeightSum += pdKernel[nLen+i];
}
}
pdTemp[yszcx+x] = dDotMul/dWeightSum;
}
}
//y方向滤波
for(x=0; x<szcx;x++)
{
for(y=0; y<szcy; y++)
{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
if((i+y)>=0 && (i+y)< szcy)
{
dDotMul += (double)pdTemp[(y+i)szcx+x]pdKernel[nLen+i];
dWeightSum += pdKernel[nLen+i];
}
}
pResult[yszcx+x] = (unsigned char)(int)dDotMul/dWeightSum;
}
}
delete []pdKernel;
pdKernel = NULL;
delete []pdTemp;
pdTemp = NULL;
}
// 方向导数,求梯度
void CFunction::Grad(SIZE sz, LPBYTE pGray,int pGradX, int pGradY, int pMag)
{
LONG y,x;
//x方向的方向导数
for(y=1;y<szcy-1;y++)
{
for(x=1;x<szcx-1;x++)
{
pGradX[yszcx +x] = (int)( pGray[yszcx+x+1]-pGray[yszcx+ x-1] );
}
}
//y方向方向导数
for(x=1;x<szcx-1;x++)
{
for(y=1;y<szcy-1;y++)
{
pGradY[yszcx +x] = (int)(pGray[(y+1)szcx +x] - pGray[(y-1)szcx +x]);
}
}
//求梯度
//中间变量
double dSqt1;
double dSqt2;
for(y=0; y<szcy; y++)
{
for(x=0; x<szcx; x++)
{ //二阶范数求梯度
dSqt1 = pGradX[yszcx + x]pGradX[yszcx + x];
dSqt2 = pGradY[yszcx + x]pGradY[yszcx + x];
pMag[yszcx+x] = (int)(sqrt(dSqt1+dSqt2)+05);
}
}
}
//非最大抑制
void CFunction::NonmaxSuppress(int pMag, int pGradX, int pGradY, SIZE sz, LPBYTE pNSRst)
{
LONG y,x;
int nPos;
//梯度分量
int gx;
int gy;
//中间变量
int g1,g2,g3,g4;
double weight;
double dTmp,dTmp1,dTmp2;
//设置图像边缘为不可能的分界点
for(x=0;x<szcx;x++)
{
pNSRst[x] = 0;
//pNSRst[(szcy-1)szcx+x] = 0;
pNSRst[szcy-1+x] = 0;
}
for(y=0;y<szcy;y++)
{
pNSRst[yszcx] = 0;
pNSRst[yszcx + szcx-1] = 0;
}
for(y=1;y<szcy-1;y++)
{
for(x=1;x<szcx-1;x++)
{ //当前点
nPos = yszcx + x;
//如果当前像素梯度幅度为0，则不是边界点
if(pMag[nPos] == 0)
{
pNSRst[nPos] = 0;
}
else
{ //当前点的梯度幅度
dTmp = pMag[nPos];
//x,y方向导数
gx = pGradX[nPos];
gy = pGradY[nPos];
//如果方向导数y分量比x分量大，说明导数方向趋向于y分量
if(abs(gy) > abs(gx))
{
//计算插值比例
weight = fabs(gx)/fabs(gy);
g2 = pMag[nPos-szcx];
g4 = pMag[nPos+szcx];
//如果x,y两个方向导数的符号相同
//C 为当前像素，与g1-g4 的位置关系为：
//g1 g2
// C
// g4 g3
if(gxgy>0)
{
g1 = pMag[nPos-szcx-1];
g3 = pMag[nPos+szcx+1];
}
//如果x,y两个方向的方向导数方向相反
//C是当前像素，与g1-g4的关系为：
// g2 g1
// C
// g3 g4
else
{
g1 = pMag[nPos-szcx+1];
g3 = pMag[nPos+szcx-1];
}
}
//如果方向导数x分量比y分量大，说明导数的方向趋向于x分量
else
{
//插值比例
weight = fabs(gy)/fabs(gx);
g2 = pMag[nPos+1];
g4 = pMag[nPos-1];
//如果x,y两个方向的方向导数符号相同
//当前像素C与 g1-g4的关系为
// g3
// g4 C g2
// g1
if(gx gy > 0)
{
g1 = pMag[nPos+szcx+1];
g3 = pMag[nPos-szcx-1];
}
//如果x,y两个方向导数的方向相反
// C与g1-g4的关系为
// g1
// g4 C g2
// g3
else
{
g1 = pMag[nPos-szcx+1];
g3 = pMag[nPos+szcx-1];
}
}
//利用 g1-g4 对梯度进行插值
{
dTmp1 = weightg1 + (1-weight)g2;
dTmp2 = weightg3 + (1-weight)g4;
//当前像素的梯度是局部的最大值
//该点可能是边界点
if(dTmp>=dTmp1 && dTmp>=dTmp2)
{
pNSRst[nPos] = 128;
}
else
{
//不可能是边界点
pNSRst[nPos] = 0;
}
}
}
}
}
}
// 统计pMag的直方图，判定阈值
void CFunction::EstimateThreshold(int pMag, SIZE sz, int pThrHigh, int pThrLow, LPBYTE pGray,
double dRatHigh, double dRatLow)
{
LONG y,x,k;
//该数组的大小和梯度值的范围有关，如果采用本程序的算法
//那么梯度的范围不会超过pow(2,10)
int nHist[1024];
//可能边界数
int nEdgeNum;
//最大梯度数
int nMaxMag;
int nHighCount;
nMaxMag = 0;
//初始化
for(k=0;k<1024;k++)
{
nHist[k] = 0;
}
//统计直方图,利用直方图计算阈值
for(y=0;y<szcy;y++)
{
for(x=0;x<szcx;x++)
{
if(pGray[yszcx+x]==128)
{
nHist[pMag[yszcx+x]]++;
}
}
}
nEdgeNum = nHist[0];
nMaxMag = 0;
//统计经过“非最大值抑制”后有多少像素
for(k=1;k<1024;k++)
{
if(nHist[k] != 0)
{
nMaxMag = k;
}
//梯度为0的点是不可能为边界点的
//经过non-maximum suppression后有多少像素
nEdgeNum += nHist[k];
}
//梯度比高阈值pThrHigh 小的像素点总书目
nHighCount = (int)(dRatHigh nEdgeNum + 05);
k=1;
nEdgeNum = nHist[1];
//计算高阈值
while((k<(nMaxMag-1)) && (nEdgeNum < nHighCount))
{
k++;
nEdgeNum += nHist[k];
}
pThrHigh = k;
//低阈值
pThrLow = (int)((pThrHigh) dRatLow + 05);
}
//利用函数寻找边界起点
void CFunction::Hysteresis(int pMag, SIZE sz, double dRatLow, double dRatHigh, LPBYTE pResult)
{
LONG y,x;
int nThrHigh,nThrLow;
int nPos;
//估计TraceEdge 函数需要的低阈值，以及Hysteresis函数使用的高阈值
EstimateThreshold(pMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow);
//寻找大于dThrHigh的点，这些点用来当作边界点，
//然后用TraceEdge函数跟踪该点对应的边界
for(y=0;y<szcy;y++)
{
for(x=0;x<szcx;x++)
{
nPos = yszcx + x;
//如果该像素是可能的边界点，并且梯度大于高阈值，
//该像素作为一个边界的起点
if((pResult[nPos]==128) && (pMag[nPos] >= nThrHigh))
{
//设置该点为边界点
pResult[nPos] = 255;
TraceEdge(y,x,nThrLow,pResult,pMag,sz);
}
}
}
//其他点已经不可能为边界点
for(y=0;y<szcy;y++)
{
for(x=0;x<szcx;x++)
{
nPos = yszcx + x;
if(pResult[nPos] != 255)
{
pResult[nPos] = 0;
}
}
}
}
//根据Hysteresis 执行的结果，从一个像素点开始搜索，搜索以该像素点为边界起点的一条边界的
//一条边界的所有边界点，函数采用了递归算法
// 从（x,y)坐标出发，进行边界点的跟踪，跟踪只考虑pResult中没有处理并且可能是边界
// 点的像素（=128），像素值为0表明该点不可能是边界点，像素值为255表明该点已经是边界点
void CFunction::TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int pMag, SIZE sz)
{
//对8邻域像素进行查询
int xNum[8] = {1,1,0,-1,-1,-1,0,1};
int yNum[8] = {0,1,1,1,0,-1,-1,-1};
LONG yy,xx,k; //循环变量
for(k=0;k<8;k++)
{
yy = y+yNum[k];
xx = x+xNum[k];
if(pResult[640 (479 - yy)+xx]==128 && pMag[640 (479 - yy)+xx]>=nThrLow )
{
//该点设为边界点
pResult[640 (479 - yy)+xx] = 255;
//以该点为中心再进行跟踪
TraceEdge(yy,xx,nThrLow,pResult,pMag,sz);
}
}
}
// Canny算子
BOOL CFunction::Canny(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=ptRightx-ptLeftx+1;
Higth=ptRighty-ptLefty+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];
}
}
//第一步进行高斯平滑器滤波
//进入循环,使用33的结构元素，处理除去第一行和最后一行以及第一列和最后一列。
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)
{
Position=640 (479 - pointy)+pointx;
for (m = 0;m < 3;m++)
{
for (n = 0;n < 3;n++)
{
array[m3+n]=m_pDibData[Position+640(1-m)+n-1];
}
}
GradHori=abs(array[0]+2array[1]+array[2]+2array[3]+4array[4]+2array[5]+array[6]+2array[7]+array[8]);
GradHori=(int)(00625GradHori+05);
if (GradHori>255)
{
m_Newdata[Position]=255;
}
else
m_Newdata[Position]=GradHori;
}
}
//第二步用一阶偏导的有限差分来计算梯度的幅值和方向
//x方向的方向导数
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)
{
pGradX[pointyWidth +pointx]=(int)(m_Newdata[pointyWidth +pointx+1]- m_Newdata[pointyWidth +pointx-1] );
}
}
//y方向方向导数
for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)
{
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
pGradY[pointyWidth +pointx] = (int)(m_Newdata[(pointy+1)Width +pointx] - m_Newdata[(pointy-1)Width +pointx]);
}
}
//求梯度
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)
{
Position=640 (479 - pointy)+pointx;
for (m = 0;m < 3;m++)
{
for (n = 0;n < 3;n++)
{
array[m3+n]=m_Newdata[Position+640(1-m)+n-1];
}
}
GradHori=abs((-1)array[0]+(-2)array[3]+2array[7]+array[8]);
GradVert=abs((-1)array[0]-2array[1]+2array[5]+array[8]);
GradHori =(int)((float)sqrt(pow(GradHori,2)+pow(GradVert,2))+05);
pGradMag[Position]=GradHori;
}
}
//针对第一行的像素点及最后一行的像素点
for (pointx = ptLeftx;pointx <= ptRightx;pointx++)
{
Position=640 (479 - ptLefty)+pointx;
pGradMag[Position]=0;
Position=640 (479 - ptRighty)+pointx;
pGradMag[Position]=0;
}
//针对第一列以及最后一列的像素点
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
Position=640 (479 - pointy)+ptLeftx;
pGradMag[Position]=0;
Position=640 (479 - pointy)+ptRightx;
pGradMag[Position]=0;
}
//第三步进行抑制梯度图中的非局部极值点的像素
for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-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(gxgy>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 = weightg1 + (1-weight)g2;
dTmp2 = weightg3 + (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 = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-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 = ptLefty+1;pointy <= ptRighty-1;pointy++)
{
for (pointx = ptLeftx+1;pointx <= ptRightx-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;
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）