2015-05-13 11:44:59 buaalei 阅读数 7122
  • Kaggle 神器:XGBoost 从基础到实战

    主讲老师冒老师为计算机博士,现在中科院从事科研教学工作,十余年机器学习教学经验,主持国家级科研项目3项,研究方向为机器学习、计算机视觉及多媒体处理。 XGBoost是"极端梯度提升"(eXtreme Gradient Boosting)的简称。XGBoost源于梯度提升框架,但是能并行计算、近似建树、对稀疏数据的有效处理以及内存使用优化,这使得XGBoost至少比现有梯度提升实现有至少10倍的速度提升。XGBoost可以处理回归、分类和排序等多种任务。由于它在预测性能上的强大且训练速度快,XGBoost已屡屡斩获Kaggle各大竞赛的冠军宝座。

    39275 人正在学习 去看看 AI100讲师

利用X方向与Y方向分别实现一阶微分,求取振幅,实现图像梯度效果,微分算子Prewitt与Sobel。

其中Sobel的表示:

 

梯度幅值:

在X, Y两个方向算子分别为:


Prewitt在X, Y方向上梯度算子分别为:

opencv Sobel算子函数:

void Sobel(InputArray src, OutputArray dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0,int borderType=BORDER_DEFAULT )
参数
src – 输入图像。
dst – 输出图像,与输入图像同样大小,拥有同样个数的通道。
ddepth –
输出图片深度;下面是输入图像支持深度和输出图像支持深度的关系:
src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F
src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F
src.depth() = CV_64F, ddepth = -1/CV_64F
当 ddepth为-1时, 输出图像将和输入图像有相同的深度。输入8位图像则会截取顶端的导数。
xorder – x方向导数运算参数。
yorder – y方向导数运算参数。
ksize – Sobel内核的大小,可以是:1,3,5,7。
scale – 可选的缩放导数的比例常数。
delta – 可选的增量常数被叠加到导数中。
borderType – 用于判断图像边界的模式。

//在x方向求图像近似导数

Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
//在y方向求图像近似导数
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );

如果我们打印上面两个输出矩阵,可以看到grad_x和grad_y中的元素有正有负。

当然,正方向递增就是正的,正方向递减则是负值,我们可以用来判断梯度方向。


convertScaleAbs函数
线性变换转换输入数组元素成8位无符号整型。
void convertScaleAbs(InputArray src, OutputArray dst, double alpha=1, double beta=0)
参数
src – 输入数组。
dst – 输出数组。
alpha – 可选缩放比例常数。
beta – 可选叠加到结果的常数。
对于每个输入数组的元素函数convertScaleAbs 进行三次操作依次是:缩放,得到一个绝对值,转换成无符号8位类型。
对于多通道矩阵,该函数对各通道独立处理。如果输出不是8位,将调用Mat::convertTo 方法并计算结果的绝对值。


addWeighted函数
计算两个矩阵的加权和。
void addWeighted(InputArray src1, double alpha, InputArray src2, double beta, double gamma, OutputArray dst, intdtype=-1)
参数
src1 – 第一个输入数组。
alpha – 第一个数组的加权系数。
src2 – 第二个输入数组,必须和第一个数组拥有相同的大小和通道。
beta – 第二个数组的加权系数。
dst – 输出数组,和第一个数组拥有相同的大小和通道。
gamma – 对所有和的叠加的常量。
dtype – 输出数组中的可选的深度,当两个数组具有相同的深度,此系数可设为-1,意义等同于选择与第一个数组相同的深度。
在多通道情况下,每个通道是独立处理的,该函数可以被替换成一个函数表达式:
dst = src1*alpha + src2*beta + gamma;


使用方法:

  /////////////////////////// Sobe l////////////////////////////////////
  /// Generate grad_x and grad_y
  Mat grad_x, grad_y;
  Mat abs_grad_x, abs_grad_y;
  /// Gradient X
  //Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
  //Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.
  Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );   
  convertScaleAbs( grad_x, abs_grad_x );
  /// Gradient Y  
  //Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
  Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );   
  convertScaleAbs( grad_y, abs_grad_y );
  /// Total Gradient (approximate)
  addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );


2019-08-03 22:37:59 shinian1987 阅读数 260
  • Kaggle 神器:XGBoost 从基础到实战

    主讲老师冒老师为计算机博士,现在中科院从事科研教学工作,十余年机器学习教学经验,主持国家级科研项目3项,研究方向为机器学习、计算机视觉及多媒体处理。 XGBoost是"极端梯度提升"(eXtreme Gradient Boosting)的简称。XGBoost源于梯度提升框架,但是能并行计算、近似建树、对稀疏数据的有效处理以及内存使用优化,这使得XGBoost至少比现有梯度提升实现有至少10倍的速度提升。XGBoost可以处理回归、分类和排序等多种任务。由于它在预测性能上的强大且训练速度快,XGBoost已屡屡斩获Kaggle各大竞赛的冠军宝座。

    39275 人正在学习 去看看 AI100讲师

学过图像处理的人,对图像梯度的概念应该都不陌生,图像梯度,可以将一个图像值变成一个向量,如下图所示:

在这里插入图片描述

简单来说,就是对像素值,在 x, y 方向进行求导,从而可以得到图像在 x, y 方向的梯度,梯度域的图像处理,就是利用梯度的性质,对图像梯度进行计算,从而达到某些特定的效果,梯度域的图像处理最有名的就是泊松编辑,此外还有 tone-mapping, 图像拼接,图像融合等等,都可以用这种方法来实现。

在介绍梯度域的图像处理的原理之前,我们先来看看几个概念:
梯度,旋度,散度

  • 梯度: 梯度的概念我们应该比较熟悉,梯度是一个向量,会指向变化最大的地方,而梯度大小,表示变化的幅度
  • 散度: 散度的运算对象是向量,散度表示的是向量场中某个点的发散程度,是远离这个点,还是向这个点聚集
  • 旋度: 旋度的运算对象也是向量,旋度表示的是向量场中,以某个点为中心,其周围点绕其旋转的程度。

旋度的表达:

Curl(I)=×I Curl(\triangledown I) = \triangledown \times \triangledown I

散度的表达:

Div(I)=I Div(\triangledown I) = \triangledown \cdot \triangledown I

对于图像来说,两者存在如下的关系:

在这里插入图片描述
在图像处理中,我们知道,Ixy=IyxI_{xy} = I_{yx},因为图像的二阶导和求导顺序是没有关系的,所以图像梯度的旋度为 0,图像的二阶导一般都是用拉普拉斯算子实现。

梯度域的图像处理,一般来说,其 pipeline 如下:
在这里插入图片描述
图片来源于: ICCV 2007 Course – Gradient Domain Manipulation Techniques

最困难的部分,应该是重建部分,假设我们要重建的图像为 II,其已知的梯度为 v\mathbf{v},那么我们主要就是要解决如下的优化方程:

minfΩfv2 \min_{f} \iint_{\Omega} | \triangledown f - \mathbf{v}|^2

其中,f\triangledown f 表示待求图像 ff 的梯度,v\mathbf{v} 表示已知的梯度,最后可以化简成求解如下的泊松方程:

Δf=divv \Delta f = \text{div} \mathbf{v}

在这里插入图片描述
其中,Δf\Delta f 表示图像 ff 的二阶导数,$ \text{div} \mathbf{v}$ 表示已知梯度的散度,图像的二阶导数,可以用拉普拉斯算子来实现,上面的优化表达式意味着,希望待求图像 ff 的梯度和已知的梯度处处相等,所以有:

Δfp=Δgp \Delta f_p = \Delta g_p

对于离散图像,一个像素点的二阶导,可以用拉普拉斯算子实现:

在这里插入图片描述
对应的 kernel 如下所示:

在这里插入图片描述
如果我们用一个稀疏矩阵来表示 拉普拉斯算子,那么可以得到如下的线性方程组:

Ax=b\mathbf{A} \mathbf{x} = \mathbf{b}

其中,KaTeX parse error: Expected 'EOF', got '\mahtbf' at position 1: \̲m̲a̲h̲t̲b̲f̲{A} 是拉普拉斯算子组成的稀疏矩阵,x\mathbf{x} 表示要求的图像,被拉成了一维列向量,b\mathbf{b} 是已知的梯度的散度,拉成的一维向量,很显然,这是一个非常庞大的矩阵。

梯度,旋度,散度的概念参考了知乎上的解释:
https://www.zhihu.com/question/24074028/answer/26657334

参考文献: computational photograph, CMU 2018 lecture 10
参考文献: ICCV 2007 Course – Gradient Domain Manipulation Techniques
同样参考了:图像处理中的全局优化技术: https://blog.csdn.net/mulinb/article/details/9079645

2018-11-26 20:14:41 FPGATOM 阅读数 279
  • Kaggle 神器:XGBoost 从基础到实战

    主讲老师冒老师为计算机博士,现在中科院从事科研教学工作,十余年机器学习教学经验,主持国家级科研项目3项,研究方向为机器学习、计算机视觉及多媒体处理。 XGBoost是"极端梯度提升"(eXtreme Gradient Boosting)的简称。XGBoost源于梯度提升框架,但是能并行计算、近似建树、对稀疏数据的有效处理以及内存使用优化,这使得XGBoost至少比现有梯度提升实现有至少10倍的速度提升。XGBoost可以处理回归、分类和排序等多种任务。由于它在预测性能上的强大且训练速度快,XGBoost已屡屡斩获Kaggle各大竞赛的冠军宝座。

    39275 人正在学习 去看看 AI100讲师

0、图像梯度

梯度的方向是函数变化最快的方向, 当图像中存在边缘时,一定有较大的梯度值。相反,当图像中有比较平滑的部分时,灰度值变化较小,相应的梯度也较小。 图像处理中把梯度的模简称为梯度。 通常我们用小区域模板进行卷积来计算梯度,常用的梯度算子有Sobel算子,Robinson算子,Laplace算子等。

1、离散图像的梯度

图像是一个离散空间,无法真正的求导,只有通过多项式拟合图像中某一点的导数,然后将该点处的x,y方向的导数视为该点的梯度。
梯度计算公式:

grad(x,y) = dx*i + dy*j
dx(i,j) = I(i+1,j)  - I(i,j)  //X方向偏导,该行与上一行的差值
dy(i,j) = I(i,j+1) - I(i,j)  //Y方向偏导,该列与上一列的差值

图像的一阶导数通常会产生较粗的边缘
代码实现:

//////////////////////////////////////////////////////////////////////////
/// \brief  图像梯度求解原型
/// \remark 
/// \param[in]  src    源灰度图
/// \param[in]  width  源灰度图宽
/// \param[in]  height  源灰度图高
/// \param[in/out]  grad_x   x方向梯度
/// \param[in/out]  grad_y   y方向梯度
/// \return     void
//////////////////////////////////////////////////////////////////////////
void Calcul_Gradian(const unsigned char*  src, int width, int height, char *  grad_x, char* grad_y)
{
   int rows = 0, cols = 0;

   for (rows = 0; rows < height - 1; rows++)
   {
       int idx = rows * width;

       for (cols = 0; cols < width - 1; cols++)
       {
           grad_x[idx + cols] = src[idx + cols + 1] - src[idx + cols];
           grad_y[idx + cols] = src[idx + cols + width] - src[idx + cols];
       }
   }
}

2、输出

Y方向–水平边缘明显,垂直边缘不明显(窗户那边明显看得出)
在这里插入图片描述

X方向–垂直边缘明显,水平边缘不明显(窗户那边明显看得出)
在这里插入图片描述

3、参考

https://blog.csdn.net/image_seg/article/details/78790968
https://blog.csdn.net/xieyan0811/article/details/70882266
https://blog.csdn.net/Touch_Dream/article/details/62447801

2017-02-05 08:17:44 longkey_zsb 阅读数 519
  • Kaggle 神器:XGBoost 从基础到实战

    主讲老师冒老师为计算机博士,现在中科院从事科研教学工作,十余年机器学习教学经验,主持国家级科研项目3项,研究方向为机器学习、计算机视觉及多媒体处理。 XGBoost是"极端梯度提升"(eXtreme Gradient Boosting)的简称。XGBoost源于梯度提升框架,但是能并行计算、近似建树、对稀疏数据的有效处理以及内存使用优化,这使得XGBoost至少比现有梯度提升实现有至少10倍的速度提升。XGBoost可以处理回归、分类和排序等多种任务。由于它在预测性能上的强大且训练速度快,XGBoost已屡屡斩获Kaggle各大竞赛的冠军宝座。

    39275 人正在学习 去看看 AI100讲师

看见别人写的博客:图像处理之图像梯度效果,感觉和我以前写的彩色边缘差不多。看不懂对方的代码,感觉我的C#代码更简单些,引用做个比较吧

http://blog.csdn.net/jia20003/article/details/7664777

下面是原图

我的代码效果                                                                                                

 

 

 

 

 

 

 

 

 

 

 

 

 

他的效果:

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 private static Bitmap smoothed高彩边缘(Bitmap a)
        {
            int w = a.Width;
            int h = a.Height;
            try
            {
                Bitmap dstBitmap = new Bitmap(w, h, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                System.Drawing.Imaging.BitmapData srcData = a.LockBits(new Rectangle (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                System.Drawing.Imaging.BitmapData dstData = dstBitmap.LockBits(new Rectangle (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
                unsafe
                {
                    byte* pIn = (byte*)srcData.Scan0.ToPointer();
                    byte* pOut = (byte*)dstData.Scan0.ToPointer();
                    byte* p;
                    int stride = srcData.Stride;
                    for (int y = 0; y < h; y++)
                    {
                        for (int x = 0; x < w; x++)
                        {
                            //边缘点像素不变
                            if (x == 0 || x == w - 1 || y == 0 || y == h - 1)
                            {
                                pOut[0] = pIn[0];
                                pOut[1] = pIn[1];
                                pOut[2] = pIn[2];
                            }
                            else
                            {
                                rgbClassPtr rgb0 = new rgbClassPtr();
                                rgb0.SetRGB( pIn[2], pIn[1], pIn[0]);
                                rgb0.GetXZD();
                                int CurR, r1, r2, r3, r4, r5, r6, r7, r8;
                                int g1, g2, g3, g4, g5, g6, g7, g8, CurG;
                                int b1, b2, b3, b4, b5, b6, b7, b8, CurB;
                                int vR, vG, vB;
                                //上一行,左上
                                p = pIn - stride - 3;
                                r1 = p[2];
                                g1 = p[1];
                                b1 = p[0];
                                //上一行,正上
                                p = pIn - stride;
                                r2 = p[2];
                                g2 = p[1];
                                b2 = p[0];
                                //上一行,右上
                                p = pIn - stride + 3;
                                r3 = p[2];
                                g3 = p[1];
                                b3 = p[0];
                                //当前行,左
                                p = pIn - 3;
                                r4 = p[2];
                                g4 = p[1];
                                b4 = p[0];
                                //当前行,右
                                p = pIn + 3;
                                r5 = p[2];
                                g5 = p[1];
                                b5 = p[0];
                                //下一行,左下
                                p = pIn + stride - 3;
                                r6 = p[2];
                                g6 = p[1];
                                b6 = p[0];
                                //下一行,正下
                                p = pIn + stride;
                                r7 = p[2];
                                g7 = p[1];
                                b7 = p[0];
                                // 下一行,右下 
                                p = pIn + stride + 3;
                                r8 = p[2];
                                g8 = p[1];
                                b8 = p[0];
                                //中心点
                                p = pIn;
                                CurR = p[2];
                                CurG = p[1];
                                CurB = p[0];
                                //使用模板
                                //1,2,3
                                //4,0,5
                                //6,7,8 
                                //int 变化量R = Math.Abs(8 * rgb0.R - r1 - r2 - r3 - r4 - r5 - r6 - r7 - r8);
                                //int 变化量G = Math.Abs(8 * rgb0.G - g1 - g2 - g3 - g4 - g5 - g6 - g7 - g8);
                                //int 变化量B = Math.Abs(8 * rgb0.B - b1 - b2 - b3 - b4 - b5 - b6 - b7 - b8);
                                // int 变化量=变化量R+变化量G+变化量B;
                                // if (变化量 < 60)
                                // {//没变化的块区
                                //     pOut[0] = (byte)0;
                                //     pOut[1] = (byte)255;
                                //     pOut[2] = (byte)0;

                                //     pIn += 3;
                                //     pOut += 3;
                                //     continue;
                                // } 
                                 
                                vR = (int)(Math.Abs(r3 + r5 + r8 - r1 - r4 - r6) + Math.Abs(r1 + r2 + r3 - r6 - r7 - r8));
                                vG = (int)(Math.Abs(g3 + g5 + g8 - g1 - g4 - g6) + Math.Abs(g1 + g2 + g3 - g6 - g7 - g8));
                                vB = (int)(Math.Abs(b3 + b5 + b8 - b1 - b4 - b6) + Math.Abs(b1 + b2 + b3 - b6 - b7 - b8));
                               
                                if (vR > 255)
                                {
                                    vR = Math.Min(255, vR);
                                }
                                
                                if (vG > 255)
                                {
                                    vG = Math.Min(255, vG);
                                }
                                
                                if (vB > 255)
                                {
                                    vB = Math.Min(255, vB);
                                }
                                if (vR < 30 && vG < 30 & vB < 30)
                                {//没变化的块区
                                    pOut[0] = (byte)0;
                                    pOut[1] = (byte)0;
                                    pOut[2] = (byte)0;


                                }
                                else
                                {
                                    pOut[0] = (byte)vB;
                                    pOut[1] = (byte)vG;
                                    pOut[2] = (byte)vR;
                                }
                            }
                            pIn += 3;
                            pOut += 3;
                        }
                        pIn += srcData.Stride - w * 3;
                        pOut += srcData.Stride - w * 3;
                    }
                }
                a.UnlockBits(srcData);
                dstBitmap.UnlockBits(dstData);
                return dstBitmap;
            }
            catch
            {
                return null;
            }

        }

 

 

 

 

 

 

 

 

 

 

 

 

 

2019-10-15 20:10:35 qq_30460949 阅读数 66
  • Kaggle 神器:XGBoost 从基础到实战

    主讲老师冒老师为计算机博士,现在中科院从事科研教学工作,十余年机器学习教学经验,主持国家级科研项目3项,研究方向为机器学习、计算机视觉及多媒体处理。 XGBoost是"极端梯度提升"(eXtreme Gradient Boosting)的简称。XGBoost源于梯度提升框架,但是能并行计算、近似建树、对稀疏数据的有效处理以及内存使用优化,这使得XGBoost至少比现有梯度提升实现有至少10倍的速度提升。XGBoost可以处理回归、分类和排序等多种任务。由于它在预测性能上的强大且训练速度快,XGBoost已屡屡斩获Kaggle各大竞赛的冠军宝座。

    39275 人正在学习 去看看 AI100讲师

第七节 方向导数与梯度

图像梯度

方向导数 

有限差分 

 梯度

 图像梯度

 图像梯度的定义

       图像函数f(x,y)在点(x,y)的梯度是一个具有大小和方向的矢量,设为Gx 和 Gy 分别表示x方向和y方向的梯度,这个梯度的矢量可以表示为:

由此可见,梯度指出了在(x,y)处f的最大变化率的方向。

这个矢量的幅度为

图像处理中一阶微分是用梯度幅值来实现的。

方向角

对于数字图像而言,图像可看成二维离散函数,图像梯度其实就是这个二维离散函数的求导,如下:

分别对X,Y两个方向上求出它们的偏微分,最终得到梯度Delta F。

G(x,y) = dx(i,j) + dy(i,j);

dx(i,j)  = I(i+1,j) - I(i,j);

dy(i,j)  = I(i,j+1) - I(i,j);

图像梯度一般也可以用中值差分:

  dx(i,j) = [I(i+1,j) - I(i-1,j)]/2;
  dy(i,j) = [I(i,j+1) - I(i,j-1)]/2;

图像边缘一般都是对图像进行梯度运算来实现的。梯度的正负反映其边缘的走势,相当于方向。由于图像在计算机中以数字图像的形式进行存储,即图像是离散的数字信号,对数字图像的梯度使用差分来代替连续信号中的微分。

数字图像中,更多的使用差分来近似导数,最简单的梯度近似表达式如下:

       梯度的方向是函数f(x,y)变化最快的方向,当图像中存在边缘时,一定有较大的梯度值,相反,当图像中有比较平滑的部分时,灰度值变化较小,则相应的梯度也较小,图像处理中把梯度的模简称为梯度,由图像梯度构成的图像成为梯度图像。

        对于离散的图像来说,一阶微分的数学表达相当于两个相邻像素的差值,根据选择的梯度算子不同,效果可能有所不同,但是基本原理不会变化。最常见的算子为Roberts算子,其它常见还有Sobel,Prewitt等算子。

Roberts算子

计算Roberts为例的X,Y的梯度演示如下图:

图像微分(梯度计算)是图像边缘提取的重要的中间步骤,根据X,Y方向的梯度向量值,可以得到如下两个重要参数振幅magnitude, 角度theta,计算公式如下:

                                                                     Theta = tan-1(yGradient/xGradient)

       magnitude表示边缘强度信息,theta预言边缘的方向走势。假如对一幅数字图像,求出magnitude之后与原来每个像素点对应值相加,则图像边缘将被大大加强,轮廓更加明显,是一个很典型的sharp filter的效果。

Sobel算子

       该算子包含两组3x3的矩阵,分别为横向及纵向,将之与图像作平面卷积,即可分别得出横向及纵向的亮度差分近似值。如果以A代表原始图像,Gx及Gy分别代表经横向及纵向边缘检测的图像灰度值,其公式如下:

具体计算如下:

图像的每一个像素的横向及纵向灰度值通过以下公式结合,来计算该点灰度的大小:

通常,为了提高效率使用不开平方的近似值:

然后可用以下公式计算梯度方向:

若图像为: 

则使用近似公式的计算的结果为:

        这样的形式很好理解,假如中间为边缘,那么边缘两侧的亮度差距就会变大,乘以符号相反的系数,会使得最终的结果达到很大的值,在图像上来看就是白色;而不是边缘的区域,左右两边或者上下两边就会抵消,在图像上看就是黑色。

       物理意义为:梯度的方向是函数f(x,y)变化最快的方向,当图像中存在边缘时,一定有较大的梯度值,相反,当图像中有比较平滑的部分时,灰度值变化较小,则相应的梯度也较小,图像处理中把梯度的模简称为梯度,由图像梯度构成的图像成为梯度图像。求导操作不仅能够捕获轮廓,人影和一些纹理信息,还能进一步弱化光照的影响。

Scharr算子 

 举例

我们先考虑下x方向,选取某个像素,假设其像素值是100,沿x方向的相邻像素分别是90,90,90,则根据上面的计算其x方向梯度分别是10,0,0。这里只取变化率的绝对值,表明变化的大小即可。

这里写图片描述


我们看到,100和90之间亮度相差10,并不是很明显,与一大群90的连续灰度值在一起,轮廓必然是模糊的。我们注意到,如果相邻像素灰度值有变化,那么梯度就有值,如果相邻像素灰度值没有变化,那么梯度就为0。如果我们把梯度值与对应的像素相加,那么灰度值没有变化的,像素值不变,而有梯度值的,灰度值变大了。

这里写图片描述
       我们看到,相加后的新图像,原图像像素点100与90亮度只相差10,现在是110与90,亮度相差20了,对比度显然增强了,尤其是图像中物体的轮廓和边缘,与背景大大加强了区别,这就是用梯度来增强图像的原理。

 

图像处理中的梯度

阅读数 10261

没有更多推荐了,返回首页