python的图像处理_python图像处理如何去除图像边缘不完整的图像 - CSDN
  • 前面一篇文章我讲解了Python图像量化、采样处理及图像金字塔。本文主要讲解图像傅里叶变换的相关内容,在数字图像处理中,有两个经典的变换被广泛应用——傅里叶变换和霍夫变换。其中,傅里叶变换主要是将时间域上的...

    该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

    该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:
    [数字图像处理] 一.MFC详解显示BMP格式图片
    [数字图像处理] 二.MFC单文档分割窗口显示图片
    [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    [数字图像处理] 四.MFC对话框绘制灰度直方图
    [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
    [数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

    前文参考:
    [Python图像处理] 一.图像处理基础知识及OpenCV入门函数
    [Python图像处理] 二.OpenCV+Numpy库读取与修改像素
    [Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
    [Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
    [Python图像处理] 五.图像融合、加法运算及图像类型转换
    [Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
    [Python图像处理] 七.图像阈值化处理及算法对比
    [Python图像处理] 八.图像腐蚀与图像膨胀
    [Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
    [Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
    [Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
    [Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
    [Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
    [Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
    [Python图像处理] 十五.图像的灰度线性变换
    [Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换
    [Python图像处理] 十七.图像锐化与边缘检测之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子
    [Python图像处理] 十八.图像锐化与边缘检测之Scharr算子、Canny算子和LOG算子
    [Python图像处理] 十九.图像分割之基于K-Means聚类的区域分割
    [Python图像处理] 二十.图像量化处理和采样处理及局部马赛克特效
    [Python图像处理] 二十一.图像金字塔之图像向下取样和向上取样

    前面一篇文章我讲解了Python图像量化、采样处理及图像金字塔。本文主要讲解图像傅里叶变换的相关内容,在数字图像处理中,有两个经典的变换被广泛应用——傅里叶变换和霍夫变换。其中,傅里叶变换主要是将时间域上的信号转变为频率域上的信号,用来进行图像除噪、图像增强等处理。基础性文章,希望对你有所帮助。同时,该部分知识均为杨秀璋查阅资料撰写,转载请署名CSDN+杨秀璋及原地址出处,谢谢!!

    1.图像傅里叶变换
    2.Numpy实现傅里叶变换
    3.Numpy实现傅里叶逆变换
    4.OpenCV实现傅里叶变换
    5.OpenCV实现傅里叶逆变换


    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:
    《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
    《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
    《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015,北京.
    百度百科-傅里叶变换
    网易云课堂-高登教育 Python+OpenCV图像处理
    安安zoe-图像的傅里叶变换
    daduzimama-图像的傅里叶变换的迷思----频谱居中
    tenderwx-数字图像处理-傅里叶变换在图像处理中的应用
    小小猫钓小小鱼-深入浅出的讲解傅里叶变换(真正的通俗易懂)


    一.图像傅里叶变换原理

    傅里叶变换(Fourier Transform,简称FT)常用于数字信号处理,它的目的是将时间域上的信号转变为频率域上的信号。随着域的不同,对同一个事物的了解角度也随之改变,因此在时域中某些不好处理的地方,在频域就可以较为简单的处理。同时,可以从频域里发现一些原先不易察觉的特征。傅里叶定理指出“任何连续周期信号都可以表示成(或者无限逼近)一系列正弦信号的叠加。”

    下面引用李老师 “Python+OpenCV图像处理” 中的一个案例,非常推荐同学们去购买学习。如下图所示,他将某饮料的制作过程的时域角度转换为频域角度。

    绘制对应的时间图和频率图如下所示:

    傅里叶公式如下,其中w表示频率,t表示时间,为复变函数。它将时间域的函数表示为频率域的函数f(t)的积分。

    傅里叶变换认为一个周期函数(信号)包含多个频率分量,任意函数(信号)f(t)可通过多个周期函数(或基函数)相加合成。从物理角度理解,傅里叶变换是以一组特殊的函数(三角函数)为正交基,对原函数进行线性变换,物理意义便是原函数在各组基函数的投影。如下图所示,它是由三条正弦曲线组合成。

    傅里叶变换可以应用于图像处理中,经过对图像进行变换得到其频谱图。从谱频图里频率高低来表征图像中灰度变化剧烈程度。图像中的边缘信号和噪声信号往往是高频信号,而图像变化频繁的图像轮廓及背景等信号往往是低频信号。这时可以有针对性的对图像进行相关操作,例如图像除噪、图像增强和锐化等。

    二维图像的傅里叶变换可以用以下数学公式(15-3)表达,其中f是空间域(Spatial Domain))值,F是频域(Frequency Domain)值

    对上面的傅里叶变换有了大致的了解之后,下面通过Numpy和OpenCV分别讲解图像傅里叶变换的算法及操作代码。


    二.Numpy实现傅里叶变换

    Numpy中的 FFT包提供了函数 np.fft.fft2()可以对信号进行快速傅里叶变换,其函数原型如下所示,该输出结果是一个复数数组(Complex Ndarry)。

    fft2(a, s=None, axes=(-2, -1), norm=None)

    • a表示输入图像,阵列状的复杂数组
    • s表示整数序列,可以决定输出数组的大小。输出可选形状(每个转换轴的长度),其中s[0]表示轴0,s[1]表示轴1。对应fit(x,n)函数中的n,沿着每个轴,如果给定的形状小于输入形状,则将剪切输入。如果大于则输入将用零填充。如果未给定’s’,则使用沿’axles’指定的轴的输入形状
    • axes表示整数序列,用于计算FFT的可选轴。如果未给出,则使用最后两个轴。“axes”中的重复索引表示对该轴执行多次转换,一个元素序列意味着执行一维FFT
    • norm包括None和ortho两个选项,规范化模式(请参见numpy.fft)。默认值为无

    Numpy中的fft模块有很多函数,相关函数如下:

    #计算一维傅里叶变换
    numpy.fft.fft(a, n=None, axis=-1, norm=None)
    #计算二维的傅里叶变换
    numpy.fft.fft2(a, n=None, axis=-1, norm=None)
    #计算n维的傅里叶变换
    numpy.fft.fftn()
    #计算n维实数的傅里叶变换
    numpy.fft.rfftn()
    #返回傅里叶变换的采样频率
    numpy.fft.fftfreq()
    #将FFT输出中的直流分量移动到频谱中央
    numpy.fft.shift()

    下面的代码是通过Numpy库实现傅里叶变换,调用np.fft.fft2()快速傅里叶变换得到频率分布,接着调用np.fft.fftshift()函数将中心位置转移至中间,最终通过Matplotlib显示效果图。

    # -*- coding: utf-8 -*-
    import cv2 as cv
    import numpy as np
    from matplotlib import pyplot as plt
    
    #读取图像
    img = cv.imread('test.png', 0)
    
    #快速傅里叶变换算法得到频率分布
    f = np.fft.fft2(img)
    
    #默认结果中心点位置是在左上角,
    #调用fftshift()函数转移到中间位置
    fshift = np.fft.fftshift(f)       
    
    #fft结果是复数, 其绝对值结果是振幅
    fimg = np.log(np.abs(fshift))
    
    #展示结果
    plt.subplot(121), plt.imshow(img, 'gray'), plt.title('Original Fourier')
    plt.axis('off')
    plt.subplot(122), plt.imshow(fimg, 'gray'), plt.title('Fourier Fourier')
    plt.axis('off')
    plt.show()
    

    输出结果如图15-2所示,左边为原始图像,右边为频率分布图谱,其中越靠近中心位置频率越低,越亮(灰度值越高)的位置代表该频率的信号振幅越大。


    三.Numpy实现傅里叶逆变换

    下面介绍Numpy实现傅里叶逆变换,它是傅里叶变换的逆操作,将频谱图像转换为原始图像的过程。通过傅里叶变换将转换为频谱图,并对高频(边界)和低频(细节)部分进行处理,接着需要通过傅里叶逆变换恢复为原始效果图。频域上对图像的处理会反映在逆变换图像上,从而更好地进行图像处理。

    图像傅里叶变化主要使用的函数如下所示:

    #实现图像逆傅里叶变换,返回一个复数数组
    numpy.fft.ifft2(a, n=None, axis=-1, norm=None)
    #fftshit()函数的逆函数,它将频谱图像的中心低频部分移动至左上角
    numpy.fft.fftshift()
    #将复数转换为0至255范围
    iimg = numpy.abs(逆傅里叶变换结果)

    下面的代码分别实现了傅里叶变换和傅里叶逆变换。

    # -*- coding: utf-8 -*-
    import cv2 as cv
    import numpy as np
    from matplotlib import pyplot as plt
    
    #读取图像
    img = cv.imread('Lena.png', 0)
    
    #傅里叶变换
    f = np.fft.fft2(img)
    fshift = np.fft.fftshift(f)
    res = np.log(np.abs(fshift))
    
    #傅里叶逆变换
    ishift = np.fft.ifftshift(fshift)
    iimg = np.fft.ifft2(ishift)
    iimg = np.abs(iimg)
    
    #展示结果
    plt.subplot(131), plt.imshow(img, 'gray'), plt.title('Original Image')
    plt.axis('off')
    plt.subplot(132), plt.imshow(res, 'gray'), plt.title('Fourier Image')
    plt.axis('off')
    plt.subplot(133), plt.imshow(iimg, 'gray'), plt.title('Inverse Fourier Image')
    plt.axis('off')
    plt.show()
    

    输出结果如图15-4所示,从左至右分别为原始图像、频谱图像、逆傅里叶变换转换图像。


    四.OpenCV实现傅里叶变换

    OpenCV 中相应的函数是cv2.dft()和用Numpy输出的结果一样,但是是双通道的。第一个通道是结果的实数部分,第二个通道是结果的虚数部分,并且输入图像要首先转换成 np.float32 格式。其函数原型如下所示:

    dst = cv2.dft(src, dst=None, flags=None, nonzeroRows=None)

    • src表示输入图像,需要通过np.float32转换格式
    • dst表示输出图像,包括输出大小和尺寸
    • flags表示转换标记,其中DFT _INVERSE执行反向一维或二维转换,而不是默认的正向转换;DFT _SCALE表示缩放结果,由阵列元素的数量除以它;DFT _ROWS执行正向或反向变换输入矩阵的每个单独的行,该标志可以同时转换多个矢量,并可用于减少开销以执行3D和更高维度的转换等;DFT _COMPLEX_OUTPUT执行1D或2D实数组的正向转换,这是最快的选择,默认功能;DFT _REAL_OUTPUT执行一维或二维复数阵列的逆变换,结果通常是相同大小的复数数组,但如果输入数组具有共轭复数对称性,则输出为真实数组
    • nonzeroRows表示当参数不为零时,函数假定只有nonzeroRows输入数组的第一行(未设置)或者只有输出数组的第一个(设置)包含非零,因此函数可以处理其余的行更有效率,并节省一些时间;这种技术对计算阵列互相关或使用DFT卷积非常有用

    注意,由于输出的频谱结果是一个复数,需要调用cv2.magnitude()函数将傅里叶变换的双通道结果转换为0到255的范围。其函数原型如下:

    cv2.magnitude(x, y)

    • x表示浮点型X坐标值,即实部
    • y表示浮点型Y坐标值,即虚部
      最终输出结果为幅值,即:

    完整代码如下所示:

    # -*- coding: utf-8 -*-
    import numpy as np
    import cv2
    from matplotlib import pyplot as plt
    
    #读取图像
    img = cv2.imread('Lena.png', 0)
    
    #傅里叶变换
    dft = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT)
    
    #将频谱低频从左上角移动至中心位置
    dft_shift = np.fft.fftshift(dft)
    
    #频谱图像双通道复数转换为0-255区间
    result = 20*np.log(cv2.magnitude(dft_shift[:,:,0], dft_shift[:,:,1]))
    
    #显示图像
    plt.subplot(121), plt.imshow(img, cmap = 'gray')
    plt.title('Input Image'), plt.xticks([]), plt.yticks([])
    plt.subplot(122), plt.imshow(result, cmap = 'gray')
    plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
    plt.show()
    

    输出结果如图15-5所示,左边为原始“Lena”图,右边为转换后的频谱图像,并且保证低频位于中心位置。


    五.OpenCV实现傅里叶逆变换

    在OpenCV 中,通过函数cv2.idft()实现傅里叶逆变换,其返回结果取决于原始图像的类型和大小,原始图像可以为实数或复数。其函数原型如下所示:

    dst = cv2.idft(src[, dst[, flags[, nonzeroRows]]])

    • src表示输入图像,包括实数或复数
    • dst表示输出图像
    • flags表示转换标记
    • nonzeroRows表示要处理的dst行数,其余行的内容未定义(请参阅dft描述中的卷积示例)

    完整代码如下所示:

    # -*- coding: utf-8 -*-
    import numpy as np
    import cv2
    from matplotlib import pyplot as plt
    
    #读取图像
    img = cv2.imread('Lena.png', 0)
    
    #傅里叶变换
    dft = cv2.dft(np.float32(img), flags = cv2.DFT_COMPLEX_OUTPUT)
    dftshift = np.fft.fftshift(dft)
    res1= 20*np.log(cv2.magnitude(dftshift[:,:,0], dftshift[:,:,1]))
    
    #傅里叶逆变换
    ishift = np.fft.ifftshift(dftshift)
    iimg = cv2.idft(ishift)
    res2 = cv2.magnitude(iimg[:,:,0], iimg[:,:,1])
    
    #显示图像
    plt.subplot(131), plt.imshow(img, 'gray'), plt.title('Original Image')
    plt.axis('off')
    plt.subplot(132), plt.imshow(res1, 'gray'), plt.title('Fourier Image')
    plt.axis('off')
    plt.subplot(133), plt.imshow(res2, 'gray'), plt.title('Inverse Fourier Image')
    plt.axis('off')
    plt.show()
    

    输出结果如图15-6所示,第一幅图为原始“Lena”图,第二幅图为傅里叶变换后的频谱图像,第三幅图为傅里叶逆变换,频谱图像转换为原始图像的过程。


    六.总结

    傅里叶变换的目的并不是为了观察图像的频率分布(至少不是最终目的),更多情况下是为了对频率进行过滤,通过修改频率以达到图像增强、图像去噪、边缘检测、特征提取、压缩加密等目的。下一篇文章,作者将结合傅里叶变换和傅里叶逆变换讲解它的应用。

    时也,命也。
    英语低分数线一分,些许遗憾,但不气馁,更加努力。雄关漫道真如铁,而今迈过从头越,从头越。苍山如海,残阳如血。感谢一路陪伴的人和自己。

    无论成败,那段拼搏的日子都很美。结果只会让我更加努力,学好英语。下半年沉下心来好好做科研写文章,西藏之行,课程分享。同时,明天的博士考试加油,虽然裸泳,但也加油!还有春季招考开始准备。

    最后补充马刺小石匠精神,当一切都看起来无济于事的时候,我去看一个石匠敲石头.他一连敲了100次,石头仍然纹丝不动。但他敲第101次的时候,石头裂为两半。可我知道,让石头裂开的不是那最后一击,而是前面的一百次敲击的结果。人生路漫漫,不可能一路一帆风顺,暂时的不顺只是磨练自己的必经之路,夜最深的时候也是距黎明最近的时刻,经历过漫漫长夜的打磨,你自身会更加强大。

    最后希望这篇基础性文章对您有所帮助,如果有错误或不足之处,请海涵!

    (By:Eastmount 2019-04-23 周二下午6点写于花溪 https://blog.csdn.net/Eastmount )

    展开全文
  • 文章发布于公号【数智物语】(ID:decision_engine),关注...本文主要介绍了一些简单易懂最常用的 Python 图像处理库。 当今世界充满了各种数据,而图像是其中高的重要组成部分。然而,若想其有所应用,我们需要...

     

    文章发布于公号【数智物语】 (ID:decision_engine),关注公号不错过每一篇干货。

     

     

     

    来源 | 大数据文摘(BigDataDigest)

    编译 | 张秋玥、小七、蒋宝尚

     

     

    本文主要介绍了一些简单易懂最常用的 Python 图像处理库。

     

    当今世界充满了各种数据,而图像是其中高的重要组成部分。然而,若想其有所应用,我们需要对这些图像进行处理。图像处理是分析和操纵数字图像的过程,旨在提高其质量或从中提取一些信息,然后将其用于某些方面。

     

    图像处理中的常见任务包括显示图像,基本操作(如裁剪、翻转、旋转等),图像分割,分类和特征提取,图像恢复和图像识别等。 Python 之成为图像处理任务的最佳选择,是因为这一科学编程语言日益普及,并且其自身免费提供许多最先进的图像处理工具。

     

    让我们看一下用于图像处理任务的一些常用 Python 库。

     

    01

    scikit Image

     

    scikit-image 是一个基于 numpy 数组的开源 Python 包。 它实现了用于研究、教育和工业应用的算法和实用程序。 即使是对于那些刚接触 Python 的人,它也是一个相当简单的库。 此库代码质量非常高并已经过同行评审,是由一个活跃的志愿者社区编写的。

     

    使用说明文档:

    https://scikit-image.org/docs/stable/user_guide.html

     

    用法举例:图像过滤、模版匹配

     

    可使用“skimage”来导入该库。大多数功能都能在子模块中找到。 

     

    
     

    import matplotlib.pyplot as plt%matplotlib inlinefrom skimage import data,filtersimage = data.coins()# ... or any other NumPy array!edges = filters.sobel(image)plt.imshow(edges, cmap='gray')

     

     

    模版匹配(使用 match_template 函数)

     

     

    gallery 上还有更多例子。

     

    https://scikit-image.org/docs/dev/auto_examples/

     

    02

    Numpy

     

    Numpy 是 Python 编程的核心库之一,支持数组结构。 图像本质上是包含数据点像素的标准 Numpy 数组。 因此,通过使用基本的 NumPy 操作——例如切片、脱敏和花式索引,可以修改图像的像素值。 可以使用 skimage 加载图像并使用 matplotlib 显示。

     

    使用说明文档:

    http://www.numpy.org/

     

    用法举例:使用 Numpy 来对图像进行脱敏处理

     

    
     

    import numpy as npfrom skimage import dataimport matplotlib.pyplot as plt%matplotlib inlineimage = data.camera()type(image)numpy.ndarray #Image is a numpy arraymask = image < 87image[mask]=255plt.imshow(image, cmap='gray')

     

     

    03

    Scipy

     

    scipy 是 Python 的另一个核心科学模块,就像 Numpy 一样,可用于基本的图像处理和处理任务。值得一提的是,子模块 scipy.ndimage 提供了在 n 维 NumPy 数组上运行的函数。 该软件包目前包括线性和非线性滤波、二进制形态、B 样条插值和对象测量等功能。

     

    使用说明文档:

    https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html#correlation-and-convolution

     

    用法举例:使用 SciPy 的高斯滤波器对图像进行模糊处理

     

    
     

    from scipy import misc,ndimageface = misc.face()blurred_face = ndimage.gaussian_filter(face, sigma=3)very_blurred = ndimage.gaussian_filter(face, sigma=5)#Resultsplt.imshow(<image to be displayed>)

     

     

    04

    PIL/ Pillow

     

    PIL (Python Imaging Library) 是一个免费的 Python 编程语言库,它增加了对打开、处理和保存许多不同图像文件格式的支持。 然而,它的发展停滞不前,其最后一次更新还是在 2009 年。幸运的是, PIL 有一个正处于积极开发阶段的分支 Pillow,它非常易于安装。Pillow 能在所有主要操作系统上运行并支持 Python 3。该库包含基本的图像处理功能,包括点操作、使用一组内置卷积内核进行过滤以及颜色空间转换。

     

    使用说明文档:

    https://pillow.readthedocs.io/en/3.1.x/index.html

     

    用法举例:使用 ImageFilter 增强 Pillow 中的图像

     

    
     

    from PIL import Image, ImageFilter#Read imageim = Image.open( 'image.jpg' )#Display imageim.show()from PIL import ImageEnhanceenh = ImageEnhance.Contrast(im)enh.enhance(1.8).show("30% more contrast")

     

     

    05

    OpenCV-Python

     

    OpenCV(开源计算机视觉库,Open Source Computer Vision Library)是计算机视觉应用中使用最广泛的库之一。OpenCV-Python 是 OpenCV 的 python API。 OpenCV-Python 不仅速度快(因为后台由用 C / C ++ 编写的代码组成),也易于编码和部署(由于前端的 Python 包装器)。 这使其成为执行计算密集型计算机视觉程序的绝佳选择。

     

    使用说明文档:

    https://github.com/abidrahmank/OpenCV2-Python-Tutorials

     

    用法举例:使用 Pyramids 创建一个名为'Orapple'的新水果的功能

     

     

    06

    SimpleCV

     

    SimpleCV 也是用于构建计算机视觉应用程序的开源框架。 通过它可以访问如 OpenCV 等高性能的计算机视觉库,而无需首先了解位深度、文件格式或色彩空间等。学习难度远远小于 OpenCV,并且正如他们的标语所说,“ 它使计算机视觉变得简单 ”。支持 SimpleCV 的一些观点是:

    • 即使是初学者也可以编写简单的机器视觉测试

    • 摄像机、视频文件、图像和视频流都可以交互操作

     

    使用说明文档:

    https://simplecv.readthedocs.io/en/latest/

     

    用法举例

     

     

    07

    Mahotas

     

    Mahotas 是另一个用于 Python 的计算机视觉和图像处理库。 它包含传统的图像处理功能(如滤波和形态学操作)以及用于特征计算的更现代的计算机视觉功能(包括兴趣点检测和局部描述符)。 该接口使用 Python,适用于快速开发,但算法是用 C++ 实现的,并且针对速度进行了优化。Mahotas 库运行很快,它的代码很简单,(对其它库的)依赖性也很小。 建议阅读他们的官方文档以了解更多内容。

     

    使用说明文档:

    https://mahotas.readthedocs.io/en/latest/install.html

     

    用法举例

     

    Mahotas 库使用简单的代码来完成工作。 对于“ 寻找 Wally ”的问题,Mahotas 完成的得很好,而且代码量非常小。

     

     

    08

    SimpleITK

     

    ITK (Insight Segmentation and Registration Toolkit) 是一个开源的跨平台系统,为开发人员提供了一整套用于图像分析的软件工具。 其中, SimpleITK 是一个建立在 ITK 之上的简化层,旨在促进其在快速原型设计、教育以及脚本语言中的使用。SimpleITK 是一个包含大量组件的图像分析工具包,支持一般的过滤操作、图像分割和配准。 SimpleITK 本身是用 C++ 编写的,但可用于包括 Python 在内的大量编程语言。

     

    使用说明文档:

    https://github.com/hhatto/pgmagick

     

    这里有大量说明了如何使用 SimpleITK 进行教育和研究活动的 Jupyter notebook。notebook 中演示了如何使用 SimpleITK 进行使用 Python 和 R 编程语言的交互式图像分析。

     

    用法举例

     

    下面的动画是使用 SimpleITK 和 Python 创建的可视化的严格 CT / MR 配准过程。

     

     

    09

    pgmagick

     

    pgmagick 是 GraphicsMagick 库基于 Python 的包装器。GraphicsMagick 图像处理系统有时被称为图像处理的瑞士军刀。它提供了强大而高效的工具和库集合,支持超过 88 种主要格式图像的读取、写入和操作,包括 DPX,GIF,JPEG,JPEG-2000,PNG,PDF,PNM 和 TIFF 等重要格式。

     

    使用说明文档:

    https://github.com/hhatto/pgmagick

     

    用法举例:图片缩放、边缘提取

     

    图片缩放

     

    边缘提取

     

    10

    Pycairo

     

    Pycairo 是图形库 cairo 的一组 python 绑定。 Cairo 是一个用于绘制矢量图形的 2D 图形库。 矢量图形很有趣,因为它们在调整大小或进行变换时不会降低清晰度。Pycairo 库可以从 Python 调用 cairo 命令。

     

    使用说明文档:

    https://github.com/pygobject/pycairo

     

    用法:Pycairo 可以绘制线条、基本形状和径向渐变

     

     

    以上就是一些免费的优秀图像处理 Python 库。有些很知名,你可能已经知道或者用过,有些可能对你来说还是新的。那正好现在就上手操作一下,试一试吧!

     

    相关报道:

    https://towardsdatascience.com/image-manipulation-tools-for-python-6eb0908ed61f

     

     

    数智物语征稿启事0613.png

     

    星标我,每天多一点智慧

     

    展开全文
  • 本篇文章讲解图像灰度化处理的知识,结合OpenCV调用cv2.cvtColor()函数实现图像灰度操作,使用像素处理方法对图像进行灰度化处理。基础性知识希望对您有所帮助。 1.图像灰度化原理 2.基于OpenCV的图像灰度化处理 3....

    该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

    该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:
    [数字图像处理] 一.MFC详解显示BMP格式图片
    [数字图像处理] 二.MFC单文档分割窗口显示图片
    [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    [数字图像处理] 四.MFC对话框绘制灰度直方图
    [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
    [数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

    前文参考:
    [Python图像处理] 一.图像处理基础知识及OpenCV入门函数
    [Python图像处理] 二.OpenCV+Numpy库读取与修改像素
    [Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
    [Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
    [Python图像处理] 五.图像融合、加法运算及图像类型转换
    [Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
    [Python图像处理] 七.图像阈值化处理及算法对比
    [Python图像处理] 八.图像腐蚀与图像膨胀
    [Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
    [Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
    [Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
    [Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
    [Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算

    本篇文章讲解图像灰度化处理的知识,结合OpenCV调用cv2.cvtColor()函数实现图像灰度操作,使用像素处理方法对图像进行灰度化处理。基础性知识希望对您有所帮助。
    1.图像灰度化原理
    2.基于OpenCV的图像灰度化处理
    3.基于像素操作的图像灰度化处理

    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时,本篇文章涉及到《计算机图形学》基础知识,请大家下来补充。

    参考文献:
    杨秀璋等. 基于苗族服饰的图像锐化和边缘提取技术研究[J]. 现代计算机,2018(10).
    《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
    《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
    《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015.
    Opencv学习(十六)之颜色空间转换cvtColor()
    python+opencv+图像特效(图像灰度处理、颜色翻转、图片融合,边缘检测,浮雕效果,颜色映射)


    一.图像灰度化原理

    像灰度化是将一幅彩色图像转换为灰度化图像的过程。彩色图像通常包括R、G、B三个分量,分别显示出红绿蓝等各种颜色,灰度化就是使彩色图像的R、G、B三个分量相等的过程。灰度图像中每个像素仅具有一种样本颜色,其灰度是位于黑色与白色之间的多级色彩深度,灰度值大的像素点比较亮,反之比较暗,像素值最大为255(表示白色),像素值最小为0(表示黑色)。

    假设某点的颜色由RGB(R,G,B)组成,常见灰度处理算法如表7.1所示:

    表7.1中Gray表示灰度处理之后的颜色,然后将原始RGB(R,G,B)颜色均匀地替换成新颜色RGB(Gray,Gray,Gray),从而将彩色图片转化为灰度图像。

    一种常见的方法是将RGB三个分量求和再取平均值,但更为准确的方法是设置不同的权重,将RGB分量按不同的比例进行灰度划分。比如人类的眼睛感官蓝色的敏感度最低,敏感最高的是绿色,因此将RGB按照0.299、0.587、0.144比例加权平均能得到较合理的灰度图像,如公式7.1所示。


    二.基于OpenCV的图像灰度化处理

    在日常生活中,我们看到的大多数彩色图像都是RGB类型,但是在图像处理过程中,常常需要用到灰度图像、二值图像、HSV、HSI等颜色,OpenCV提供了cvtColor()函数实现这些功能。其函数原型如下所示:

    dst = cv2.cvtColor(src, code[, dst[, dstCn]])

    • src表示输入图像,需要进行颜色空间变换的原图像
    • dst表示输出图像,其大小和深度与src一致
    • code表示转换的代码或标识
    • dstCn表示目标图像通道数,其值为0时,则有src和code决定

    该函数的作用是将一个图像从一个颜色空间转换到另一个颜色空间,其中,RGB是指Red、Green和Blue,一副图像由这三个通道(channel)构成;Gray表示只有灰度值一个通道;HSV包含Hue(色调)、Saturation(饱和度)和Value(亮度)三个通道。在OpenCV中,常见的颜色空间转换标识包括CV_BGR2BGRA、CV_RGB2GRAY、CV_GRAY2RGB、CV_BGR2HSV、CV_BGR2XYZ、CV_BGR2HLS等。

    下面是调用cvtColor()函数将图像进行灰度化处理的代码。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    
    #读取原始图片
    src = cv2.imread('miao.png')
    
    #图像灰度化处理
    grayImage = cv2.cvtColor(src,cv2.COLOR_BGR2GRAY)
    
    #显示图像
    cv2.imshow("src", src)
    cv2.imshow("result", grayImage)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    输出结果如下图所示,左边是彩色的苗族服饰原图,右边是将彩色图像进行灰度化处理之后的灰度图。其中,灰度图将一个像素点的三个颜色变量设置为相当,R=G=B,此时该值称为灰度值。

    同样,可以调用 grayImage = cv2.cvtColor(src, cv2.COLOR_BGR2HSV) 核心代码将彩色图像转换为HSV颜色空间,如下图所示。

    下面Image_Processing_07_02.py代码对比了九种常见的颜色空间,包括BGR、RGB、GRAY、HSV、YCrCb、HLS、XYZ、LAB和YUV,并循环显示处理后的图像。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img_BGR = cv2.imread('miao.png')
    
    #BGR转换为RGB
    img_RGB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
    
    #灰度化处理
    img_GRAY = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY)
    
    #BGR转HSV
    img_HSV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HSV)
    
    #BGR转YCrCb
    img_YCrCb = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)
    
    #BGR转HLS
    img_HLS = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HLS)
    
    #BGR转XYZ
    img_XYZ = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2XYZ)
    
    #BGR转LAB
    img_LAB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2LAB)
    
    #BGR转YUV
    img_YUV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YUV)
    
    #调用matplotlib显示处理结果
    titles = ['BGR', 'RGB', 'GRAY', 'HSV', 'YCrCb', 'HLS', 'XYZ', 'LAB', 'YUV']  
    images = [img_BGR, img_RGB, img_GRAY, img_HSV, img_YCrCb,
              img_HLS, img_XYZ, img_LAB, img_YUV]  
    for i in xrange(9):  
       plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
       plt.title(titles[i])  
       plt.xticks([]),plt.yticks([])  
    plt.show()
    

    其运行结果如图所示:


    三.基于像素操作的图像灰度化处理

    前面讲述了调用OpenCV中cvtColor()函数实现图像灰度化的处理,接下来讲解基于像素操作的图像灰度化处理方法,主要是最大值灰度处理、平均灰度处理和加权平均灰度处理方法。

    1.最大值灰度处理方法
    该方法的灰度值等于彩色图像R、G、B三个分量中的最大值,公式如下:

    其方法灰度化处理后的灰度图亮度很高,实现代码如下。

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    
    #图像最大值灰度处理
    for i in range(height):
        for j in range(width):
            #获取图像R G B最大值
            gray = max(img[i,j][0], img[i,j][1], img[i,j][2])
            #灰度图像素赋值 gray=max(R,G,B)
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示,其处理效果的灰度偏亮。

    2.平均灰度处理方法
    该方法的灰度值等于彩色图像R、G、B三个分量灰度值的求和平均值,其计算公式如下所示:

    平均灰度处理方法实现代码如下所示:

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    print grayimg
    
    #图像平均灰度处理方法
    for i in range(height):
        for j in range(width):
            #灰度值为RGB三个分量的平均值
            gray = (int(img[i,j][0]) + int(img[i,j][1]) + int(img[i,j][2]))  /  3
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示:

    3.加权平均灰度处理方法
    该方法根据色彩重要性,将三个分量以不同的权值进行加权平均。由于人眼对绿色的敏感最高,对蓝色敏感最低,因此,按下式对RGB三分量进行加权平均能得到较合理的灰度图像。

    加权平均灰度处理方法实现代码如下所示:

    #encoding:utf-8
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('miao.png')
    
    #获取图像高度和宽度
    height = img.shape[0]
    width = img.shape[1]
    
    #创建一幅图像
    grayimg = np.zeros((height, width, 3), np.uint8)
    print grayimg
    
    #图像平均灰度处理方法
    for i in range(height):
        for j in range(width):
            #灰度加权平均法
            gray = 0.30 * img[i,j][0] + 0.59 * img[i,j][1] + 0.11 * img[i,j][2]
            grayimg[i,j] = np.uint8(gray)
    
    #显示图像
    cv2.imshow("src", img)
    cv2.imshow("gray", grayimg)
    
    #等待显示
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    

    其输出结果如下图所示:


    希望文章对大家有所帮助,如果有错误或不足之处,还请海涵。最近连续奔波考博,经历的事情太多,有喜有悲,需要改变自己好好对女神,也希望读者与我一起加油。
    (By:Eastmount 2019-03-25 早上8点 https://blog.csdn.net/Eastmount/)

    展开全文
  • 前面一篇文章我讲解了Python图像量化及采样处理,本文将讲解另一个知识——图像金字塔,包括图像向下采样和图像向上采样。基础性文章,希望对你有所帮助。同时,该部分知识均为杨秀璋查阅资料撰写,转载请署名CSDN+...

    该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。希望文章对您有所帮助,如果有不足之处,还请海涵~

    该系列在github所有源代码:https://github.com/eastmountyxz/ImageProcessing-Python
    PS:请求帮忙点个Star,哈哈,第一次使用Github,以后会分享更多代码,一起加油。

    同时推荐作者的C++图像系列知识:
    [数字图像处理] 一.MFC详解显示BMP格式图片
    [数字图像处理] 二.MFC单文档分割窗口显示图片
    [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    [数字图像处理] 四.MFC对话框绘制灰度直方图
    [数字图像处理] 五.MFC图像点运算之灰度线性变化、灰度非线性变化、阈值化和均衡化处理详解
    [数字图像处理] 六.MFC空间几何变换之图像平移、镜像、旋转、缩放详解
    [数字图像处理] 七.MFC图像增强之图像普通平滑、高斯平滑、Laplacian、Sobel、Prewitt锐化详解

    前文参考:
    [Python图像处理] 一.图像处理基础知识及OpenCV入门函数
    [Python图像处理] 二.OpenCV+Numpy库读取与修改像素
    [Python图像处理] 三.获取图像属性、兴趣ROI区域及通道处理
    [Python图像处理] 四.图像平滑之均值滤波、方框滤波、高斯滤波及中值滤波
    [Python图像处理] 五.图像融合、加法运算及图像类型转换
    [Python图像处理] 六.图像缩放、图像旋转、图像翻转与图像平移
    [Python图像处理] 七.图像阈值化处理及算法对比
    [Python图像处理] 八.图像腐蚀与图像膨胀
    [Python图像处理] 九.形态学之图像开运算、闭运算、梯度运算
    [Python图像处理] 十.形态学之图像顶帽运算和黑帽运算
    [Python图像处理] 十一.灰度直方图概念及OpenCV绘制直方图
    [Python图像处理] 十二.图像几何变换之图像仿射变换、图像透视变换和图像校正
    [Python图像处理] 十三.基于灰度三维图的图像顶帽运算和黑帽运算
    [Python图像处理] 十四.基于OpenCV和像素处理的图像灰度化处理
    [Python图像处理] 十五.图像的灰度线性变换
    [Python图像处理] 十六.图像的灰度非线性变换之对数变换、伽马变换
    [Python图像处理] 十七.图像锐化与边缘检测之Roberts算子、Prewitt算子、Sobel算子和Laplacian算子
    [Python图像处理] 十八.图像锐化与边缘检测之Scharr算子、Canny算子和LOG算子
    [Python图像处理] 十九.图像分割之基于K-Means聚类的区域分割
    [Python图像处理] 二十.图像量化处理和采样处理及局部马赛克特效

    前面一篇文章我讲解了Python图像量化及采样处理,本文将讲解另一个知识——图像金字塔,包括图像向下采样和图像向上采样。基础性文章,希望对你有所帮助。同时,该部分知识均为杨秀璋查阅资料撰写,转载请署名CSDN+杨秀璋及原地址出处,谢谢!!

    1.图像金字塔
    2.图像向下采样
    3.图像向上采样


    PS:文章参考自己以前系列图像处理文章及OpenCV库函数,同时参考如下文献:
    eastmount - [数字图像处理] 三.MFC实现图像灰度、采样和量化功能详解
    《数字图像处理》(第3版),冈萨雷斯著,阮秋琦译,电子工业出版社,2013年.
    《数字图像处理学》(第3版),阮秋琦,电子工业出版社,2008年,北京.
    《OpenCV3编程入门》,毛星云,冷雪飞,电子工业出版社,2015,北京.


    一.图像金字塔

    前面讲解的图像采样处理可以降低图像的大小,本小节将补充图像金字塔知识,了解专门用于图像向上采样和向下采样的pyrUp()和pyrDown()函数。

    图像金字塔是指由一组图像且不同分别率的子图集合,它是图像多尺度表达的一种,以多分辨率来解释图像的结构,主要用于图像的分割或压缩。一幅图像的金字塔是一系列以金字塔形状排列的分辨率逐步降低,且来源于同一张原始图的图像集合。如图6-11所示,它包括了四层图像,将这一层一层的图像比喻成金字塔。图像金字塔可以通过梯次向下采样获得,直到达到某个终止条件才停止采样,在向下采样中,层级越高,则图像越小,分辨率越低。

    生成图像金字塔主要包括两种方式——向下取样、向上取样。在图6-11中,将图像G0转换为G1、G2、G3,图像分辨率不断降低的过程称为向下取样;将G3转换为G2、G1、G0,图像分辨率不断增大的过程称为向上取样。


    二.图像向下取样

    在图像向下取样中,使用最多的是高斯金字塔。它将对图像Gi进行高斯核卷积,并删除原图中所有的偶数行和列,最终缩小图像。其中,高斯核卷积运算就是对整幅图像进行加权平均的过程,每一个像素点的值,都由其本身和邻域内的其他像素值(权重不同)经过加权平均后得到。常见的3×3和5×5高斯核如下:

    高斯核卷积让临近中心的像素点具有更高的重要度,对周围像素计算加权平均值,如图6-12所示,其中心位置权重最高为0.4。

    显而易见,原始图像Gi具有M×N个像素,进行向下取样之后,所得到的图像Gi+1具有M/2×N/2个像素,只有原图的四分之一。通过对输入的原始图像不停迭代以上步骤就会得到整个金字塔。注意,由于每次向下取样会删除偶数行和列,所以它会不停地丢失图像的信息。

    在OpenCV中,向下取样使用的函数为pyrDown(),其原型如下所示:

    dst = pyrDown(src[, dst[, dstsize[, borderType]]])

    • src表示输入图像,
    • dst表示输出图像,和输入图像具有一样的尺寸和类型
    • dstsize表示输出图像的大小,默认值为Size()
    • borderType表示像素外推方法,详见cv::bordertypes

    实现代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('nv.png')
    
    #图像向下取样
    r = cv2.pyrDown(img)
    
    #显示图像
    cv2.imshow('original', img)
    cv2.imshow('PyrDown', r)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    输出结果如图6-13所示,它将原始图像压缩成原图的四分之一。

    多次向下取样的代码如下:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('nv.png')
    
    #图像向下取样
    r1 = cv2.pyrDown(img)
    r2 = cv2.pyrDown(r1)
    r3 = cv2.pyrDown(r2)
    
    #显示图像
    cv2.imshow('original', img)
    cv2.imshow('PyrDown1', r1)
    cv2.imshow('PyrDown2', r2)
    cv2.imshow('PyrDown3', r3)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    输出结果如图所示:


    三.图像向上取样

    在图像向上取样是由小图像不断放图像的过程。它将图像在每个方向上扩大为原图像的2倍,新增的行和列均用0来填充,并使用与“向下取样”相同的卷积核乘以4,再与放大后的图像进行卷积运算,以获得“新增像素”的新值。如图6-15所示,它在原始像素45、123、89、149之间各新增了一行和一列值为0的像素。

    在OpenCV中,向上取样使用的函数为pyrUp(),其原型如下所示:

    dst = pyrUp(src[, dst[, dstsize[, borderType]]])

    • src表示输入图像,
    • dst表示输出图像,和输入图像具有一样的尺寸和类型
    • dstsize表示输出图像的大小,默认值为Size()
    • borderType表示像素外推方法,详见cv::bordertypes

    实现代码如下所示:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('lena.png')
    
    #图像向上取样
    r = cv2.pyrUp(img)
    
    #显示图像
    cv2.imshow('original', img)
    cv2.imshow('PyrUp', r)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    输出结果如图6-16所示,它将原始图像扩大为原图像的四倍。

    多次向上取样的代码如下:

    # -*- coding: utf-8 -*-
    import cv2  
    import numpy as np  
    import matplotlib.pyplot as plt
    
    #读取原始图像
    img = cv2.imread('lena2.png')
    
    #图像向上取样
    r1 = cv2.pyrUp(img)
    r2 = cv2.pyrUp(r1)
    r3 = cv2.pyrUp(r2)
    
    #显示图像
    cv2.imshow('original', img)
    cv2.imshow('PyrUp1', r1)
    cv2.imshow('PyrUp2', r2)
    cv2.imshow('PyrUp3', r3)
    cv2.waitKey()
    cv2.destroyAllWindows()
    

    输出结果如图6-17所示,每次向上取样均为上次图像的四倍,但图像的清晰度会降低。


    四.总结

    希望这篇基础性文章对您有所帮助,如果有错误或不足之处,请海涵!
    最近继续备考博士,接下来还有两个学校,一方面耐心等待之前的结果;另一方面继续复习,周末女神陪着来书店看书,岁月静好,砥砺前行!在这期间,自己经历了很多酸甜苦辣的事情,希望陌生的你也学会享受生活,共勉。

    (By:Eastmount 2019-04-16 周二夜8点写于贵阳·钟书阁 https://blog.csdn.net/Eastmount )

    展开全文
  • 提到图像处理第一个想到的库就是PIL,全称Python Imaging Library Python图像处理类库,它提供了大量的图像操作,比如图像缩放,裁剪,贴图,模糊等等,很多时候它需要配合numpy库一起使用 1.open() 你可以使用...

    质量、速度、廉价,选择其中两个

    提到图像处理第一个想到的库就是PIL,全称Python Imaging Library Python,图像处理类库,它提供了大量的图像操作,比如图像缩放,裁剪,贴图,模糊等等,很多时候它需要配合numpy库一起使用

    1.open()

    你可以使用Image.open打开一个图像文件,它会返回PIL图像对象

    image = Image.open(image_address)

    2.covert()

    你可以 covert() 方法转换图像格式,covert() 有三种传参方式

    im.convert(mode) ⇒ image

    im.convert(“P”, **options) ⇒ image

    im.convert(mode, matrix) ⇒ image

    最常用的还是第一种,通过该方法你可以将PIL图像转换成九种不同的格式,分别1,L,P,RGB,RGBA,CMYK,YCbCr,I,F。

    1.模式“1”

    模式“1”为二值图像,非黑即白。但是它每个像素用8个bit表示,0表示黑,255表示白。

    2.模式“L”

    模式”L”为灰色图像,它的每个像素用8个bit表示,0表示黑,255表示白,其他数字表示不同的灰度。在PIL中,从模式“RGB”转换为“L”模式是按照下面的公式转换的:

    L = R * 299/1000 + G * 587/1000+ B * 114/1000

    3.模式“p”

    模式“P”为8位彩色图像,它的每个像素用8个bit表示,其对应的彩色值是按照调色板查询出来的。

    4.模式“RGBA”

    模式“RGBA”为32位彩色图像,它的每个像素用32个bit表示,其中24bit表示红色、绿色和蓝色三个通道,另外8bit表示alpha通道,即透明通道。

    5.模式“CMYK”

    模式“CMYK”为32位彩色图像,它的每个像素用32个bit表示。模式“CMYK”就是印刷四分色模式,它是彩色印刷时采用的一种套色模式,利用色料的三原色混色原理,加上黑色油墨,共计四种颜色混合叠加,形成所谓“全彩印刷”。

    四种标准颜色是:C:Cyan = 青色,又称为‘天蓝色’或是‘湛蓝’M:Magenta = 品红色,又称为‘洋红色’;Y:Yellow = 黄色;K:Key Plate(blacK) = 定位套版色(黑色)。

    6.模式“YCbCr”

    模式“YCbCr”为24位彩色图像,它的每个像素用24个bit表示。YCbCr其中Y是指亮度分量,Cb指蓝色色度分量,而Cr指红色色度分量。人的肉眼对视频的Y分量更敏感,因此在通过对色度分量进行子采样来减少色度分量后,肉眼将察觉不到的图像质量的变化。

    模式“RGB”转换为“YCbCr”的公式如下:

    Y= 0.257*R+0.504*G+0.098*B+16
    Cb = -0.148*R-0.291*G+0.439*B+128
    Cr = 0.439*R-0.368*G-0.071*B+128

    7.模式“I”

    模式“I”为32位整型灰色图像,它的每个像素用32个bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“I”模式是按照下面的公式转换的:

    I = R * 299/1000 + G * 587/1000 + B * 114/1000

    8.模式“F”

    模式“F”为32位浮点灰色图像,它的每个像素用32个bit表示,0表示黑,255表示白,(0,255)之间的数字表示不同的灰度。在PIL中,从模式“RGB”转换为“F”模式是按照下面的公式转换的:

    F = R * 299/1000+ G * 587/1000 + B * 114/1000

    3.调整尺寸、创建缩略图、裁剪、贴图、旋转

    PIL库给我们提供了丰富基本图像操作,如果你想调整一张图片的尺寸,你可以使用resize()方法,该方法需要传入你指定新图像宽高的元组

    img = img.resize((128,128))

    如果你想创建一张图片的缩略图,你可以使用thumbnail()方法,该方法需要传入缩略图的宽高元组

    img=img.thumbnail((128,128))

    如果你想对一张图片的一部分进行裁剪,你可以使用crop()方法,该方法需要你传入一个元组,该元组指定裁剪区域的左上角坐标和右下角坐标

    box = (100,100,400,400)
    img = img.crop(box)

    如果你想把一张图片覆盖在另一个图片的上面,你可以使用paste()方法,该方法需要传入要贴的图片和位置(左上角坐标和右下角坐标)

    img2=img2.paste(img1,(100,100,200,200))

    如果你想要旋转一张图片,你可以使用transpose()方法,该方法传入旋转角度

    img = img.transpose(Image.ROTATE_180)

    不过这些角度很受限制,只可以传下面之中的一个

    • PIL.Image.FLIP_LEFT_RIGHT 
    • PIL.Image.FLIP_TOP_BOTTOM
    • PIL.Image.ROTATE_90
    • PIL.Image.ROTATE_180
    • PIL.Image.ROTATE_270
    • PIL.Image.TRANSPOSE
    • PIL.Image.TRANSVERSE

    你也可以使用rotate()方法,该方法更为简单方便,只需要传入一个旋转角度即可

    image = image.rotate(45)

    4.Numpy

    对图像进行变换其实就是对矩阵进行变换,我们需要把一张图片转换成矩阵再进行操作,使用array()方法

    image = Image.open(image_address)
    imageArray = array(image)

    1.反向处理与二值化

    图像一般都是三通道的,也就是红绿蓝,他们的值从0-255,所谓反相处理呢,就是把颜色反过来

    imageArray = 255 - imageArray

     图像的二值化也很简单,0-255以128为分界,小于128置为0否则置为1

    imageArray = 1 * (imageArray < 128)

    2.像素值限制范围

    如果你想把一个图像的像素值都限制到一个范围内,比如说你想把像素值限制到100-200这个区间上,你可以这么干

    imageArray = (100.0 / 255) * imageArray + 100

    3.像素值求平方

    imageArray = 255.0 * (imageArray / 255.0) ** 2

    4.直方图均衡化

    图像灰度变换中一个非常有用的例子就是直方图均衡化。直方图均衡化是指将一幅图像的灰度直方图变平,使变换后的图像中每个灰度值的分布概率都相同。在对图像做进一步处理之前,直方图均衡化通常是对图像灰度值进行归一化的一个非常好的方法,并且可以增强图像的对比度。

    在这种情况下,直方图均衡化的变换函数是图像中像素值的累积分布函数(cumulative distribution function,简写为 cdf,将像素值的范围映射到目标范围的归一化操作)

    def histeq(im,nbr_bins=256):
        """ 对一幅灰度图像进行直方图均衡化"""
        # 计算图像的直方图
        imhist,bins = histogram(im.flatten(),nbr_bins,normed=True)
        cdf = imhist.cumsum()
        # cumulative distribution function
        cdf = 255 * cdf / cdf[-1]
        #  归一化
        #  使用累积分布函数的线性插值,计算新的像素值
        im2 = interp(im.flatten(),bins[:-1],cdf)
        return im2.reshape(im.shape), cdf

    该函数有两个输入参数,一个是灰度图像,一个是直方图中使用小区间的数目。函数返回直方图均衡化后的图像,以及用来做像素值映射的累积分布函数。注意,函数中使用到累积分布函数的最后一个元素(下标为 -1),目的是将其归一化到 0...1 范围。

    直方图均衡化后图像可以使对比度增强,使原先图像灰色区域的细节变得更清晰

    5.多种滤波

    gaussian滤波是多维的滤波器,是一种平滑滤波,可以消除高斯噪声

    通过调节sigma的值来调整滤波效果

    imageArray = filters.gaussian_filter(imageArray, 5)

    sobel算子可用来检测边缘

    edges = filters.sobel(img)

    roberts算子、scharr算子、prewitt算子和sobel算子一样,用于检测边缘

    edges = filters.roberts(img)
    edges = filters.scharr(img)
    edges = filters.prewitt(img)

    canny算子也是用于提取边缘特征,但它不是放在filters模块,而是放在feature模块

    edges1 = feature.canny(img)   #sigma=1
    edges2 = feature.canny(img,sigma=3)   #sigma=3

    gabor滤波可用来进行边缘检测和纹理特征提取。

    通过修改frequency值来调整滤波效果,返回一对边缘结果,一个是用真实滤波核的滤波结果,一个是想象的滤波核的滤波结果。

    filt_real, filt_imag = filters.gabor_filter(img,frequency=0.6)   

    6.PCA

    PCA(Principal Component Analysis,主成分分析)是一个非常有用的降维技巧。它可以在使用尽可能少维数的前提下,尽量多地保持训练数据的信息,在此意义上是一个最佳技巧。即使是一幅 100×100 像素的小灰度图像,也有 10 000 维,可以看成 10 000 维空间中的一个点。一兆像素的图像具有百万维。由于图像具有很高的维数,在许多计算机视觉应用中,我们经常使用降维操作。PCA 产生的投影矩阵可以被视为将原始坐标变换到现有的坐标系,坐标系中的各个坐标按照重要性递减排列。

    为了对图像数据进行 PCA 变换,图像需要转换成一维向量表示。我们可以使用 NumPy 类库中的 flatten() 方法进行变换。

    将变平的图像堆积起来,我们可以得到一个矩阵,矩阵的一行表示一幅图像。在计算主方向之前,所有的行图像按照平均图像进行了中心化。我们通常使用 SVD(Singular Value Decomposition,奇异值分解)方法来计算主成分;但当矩阵的维数很大时,SVD 的计算非常慢,所以此时通常不使用 SVD 分解。下面就是 PCA 操作的代码:

    def pca(X):
        """ 主成分分析:    输入:矩阵X ,其中该矩阵中存储训练数据,每一行为一条训练数据
           返回:投影矩阵(按照维度的重要性排序)、方差和均值"""
        # 获取维数
        num_data,dim = X.shape
        # 数据中心化
        mean_X = X.mean(axis=0)
        X = X - mean_X
        if dim<num_data:
            # PCA- 使用紧致技巧
            M = dot(X,X.T)
            # 协方差矩阵
            e,EV = linalg.eigh(M)
            # 特征值和特征向量
            tmp = dot(X.T,EV).T
            # 这就是紧致技巧
            V = tmp[::-1]
            # 由于最后的特征向量是我们所需要的,所以需要将其逆转
            S = sqrt(e)[::-1]
            # 由于特征值是按照递增顺序排列的,所以需要将其逆转
            for i in range(V.shape[1]):
                V[:,i] /= S
        else:
            # PCA- 使用SVD 方法
            U,S,V = linalg.svd(X)
            V = V[:num_data]
            # 仅仅返回前nun_data 维的数据才合理
            #  返回投影矩阵、方差和均值
        return V,S,mean_X

    7.图像添加噪声和降噪

    添加噪声比降噪简单得多,只需要把图像矩阵上面随机加一些值就好了

    imageArray = imageArray + 30 * random.standard_normal(imageArray.shape)

    图像降噪是在去除图像噪声的同时,尽可能地保留图像细节和结构的处理技术,我们这里使用 ROF去燥模型

    一幅(灰度)图像 I 的全变差(Total Variation,TV)定义为梯度范数之和。在连续表示的情况下,全变差表示为:

    J(\boldsymbol{I})=\int\left|\nabla\boldsymbol{I}\right|\text{dx} 

    在离散表示的情况下,全变差表示为:

    J(\boldsymbol{I})=\sum_{\text{x}}\left|\nabla\boldsymbol{I}\right|

    其中,上面的式子是在所有图像坐标 x=[x, y] 上取和。

    在 Chambolle 提出的 ROF 模型里,目标函数为寻找降噪后的图像 U,使下式最小:

    \min_U\left|\left|\boldsymbol{I}-\boldsymbol{U}\right|\right|^2+2\lambda J(\boldsymbol{U}),

    其中范数 ||I-U|| 是去噪后图像 U 和原始图像 I 差异的度量。也就是说,本质上该模型使去噪后的图像像素值“平坦”变化,但是在图像区域的边缘上,允许去噪后的图像像素值“跳跃”变化。

    def denoise(im,U_init,tolerance=0.1,tau=0.125,tv_weight=100):
        """ 使用A. Chambolle(2005)在公式(11)中的计算步骤实现Rudin-Osher-Fatemi(ROF)去噪模型
           输入:含有噪声的输入图像(灰度图像)、U 的初始值、TV 正则项权值、步长、停业条件
            输出:去噪和去除纹理后的图像、纹理残留"""
        m,n = im.shape # 噪声图像的大小
    
        #  初始化
        U = U_init
        Px = im # 对偶域的x 分量
        Py = im # 对偶域的y 分量
        error = 1
        while (error > tolerance):
            Uold = U
    
            # 原始变量的梯度
            GradUx = roll(U,-1,axis=1)-U # 变量U 梯度的x 分量
            GradUy = roll(U,-1,axis=0)-U # 变量U 梯度的y 分量
    
            #  更新对偶变量
            PxNew = Px + (tau/tv_weight)*GradUx
            PyNew = Py + (tau/tv_weight)*GradUy
            NormNew = maximum(1,sqrt(PxNew**2+PyNew**2))
            Px = PxNew/NormNew # 更新x 分量(对偶)
            Py = PyNew/NormNew # 更新y 分量(对偶)
            #  更新原始变量
            RxPx = roll(Px,1,axis=1) # 对x 分量进行向右x 轴平移
            RyPy = roll(Py,1,axis=0) # 对y 分量进行向右y 轴平移
    
            DivP = (Px-RxPx)+(Py-RyPy) # 对偶域的散度
            U = im + tv_weight*DivP # 更新原始变量
    
            #  更新误差
            error = linalg.norm(U-Uold)/sqrt(n*m);
        return U,im-U  # 去噪后的图像和纹理残余
    

    5.Matplotlib

    我们队图像进行处理之后往往需要知道处理后变化如何,该库便可以方便地绘制出条形图,饼状图等等呢个图像,还可在上面添加标记等等

    尽管 Matplotlib 可以绘制出较好的条形图、饼状图、散点图等,但是对于大多数计算机视觉应用来说,仅仅需要用到几个绘图命令。最重要的是,我们想用点和线来表示一些事物,比如兴趣点、对应点以及检测出的物体。下面是用几个点和一条线绘制图像的例子:

    from PIL import Image
    from pylab import *
    
    # 读取图像到数组中
    im = array(Image.open('empire.jpg'))
    
    # 绘制图像
    imshow(im)
    
    # 一些点
    x = [100,100,400,400]
    y = [200,500,200,500]
    
    # 使用红色星状标记绘制点
    plot(x,y,'r*')
    
    # 绘制连接前两个点的线
    plot(x[:2],y[:2])
    
    # 添加标题,显示绘制的图像
    title('Plotting: "empire.jpg"')
    show()

    上面的代码首先绘制出原始图像,然后在 x 和 y 列表中给定点的 x 坐标和 y 坐标上绘制出红色星状标记点,最后在两个列表表示的前两个点之间绘制一条线段(默认为蓝色)。该例子的绘制结果如图 1-2 所示。show() 命令首先打开图形用户界面(GUI),然后新建一个图像窗口。该图形用户界面会循环阻断脚本,然后暂停,直到最后一个图像窗口关闭。在每个脚本里,你只能调用一次 show() 命令,而且通常是在脚本的结尾调用。注意,在 PyLab 库中,我们约定图像的左上角为坐标原点。

    图像的坐标轴是一个很有用的调试工具;但是,如果你想绘制出较美观的图像,加上下列命令可以使坐标轴不显示:

    axis('off')

     下面是我写的一个图像处理的脚本

    import PIL.Image as Image
    import os
    from pylab import *
    from numpy import *
    from scipy.ndimage import filters
    from scipy.ndimage import measurements,morphology
    
    
    def get_imlist(path):
        # 一级文件夹下有用
        # return [os.path.join(path, f) for f in os.listdir(path) if f.endswith('.jpg')]
        g = os.walk(path)
        image_list=[]
        for path, d, filelist in g:
            for filename in filelist:
                if filename.endswith('jpg'):
                    image_list.append(os.path.join(path, filename))
        return image_list
    
    def histeq(im,nbr_bins=256):
        """ 对一幅灰度图像进行直方图均衡化"""
        # 计算图像的直方图
        imhist,bins = histogram(im.flatten(),nbr_bins,normed=True)
        cdf = imhist.cumsum()
        # cumulative distribution function
        cdf = 255 * cdf / cdf[-1]
        #  归一化
        #  使用累积分布函数的线性插值,计算新的像素值
        im2 = interp(im.flatten(),bins[:-1],cdf)
        return im2.reshape(im.shape), cdf
    
    def pca(X):
        """ 主成分分析:    输入:矩阵X ,其中该矩阵中存储训练数据,每一行为一条训练数据
           返回:投影矩阵(按照维度的重要性排序)、方差和均值"""
        # 获取维数
        num_data,dim = X.shape
        # 数据中心化
        mean_X = X.mean(axis=0)
        X = X - mean_X
        if dim<num_data:
            # PCA- 使用紧致技巧
            M = dot(X,X.T)
            # 协方差矩阵
            e,EV = linalg.eigh(M)
            # 特征值和特征向量
            tmp = dot(X.T,EV).T
            # 这就是紧致技巧
            V = tmp[::-1]
            # 由于最后的特征向量是我们所需要的,所以需要将其逆转
            S = sqrt(e)[::-1]
            # 由于特征值是按照递增顺序排列的,所以需要将其逆转
            for i in range(V.shape[1]):
                V[:,i] /= S
        else:
            # PCA- 使用SVD 方法
            U,S,V = linalg.svd(X)
            V = V[:num_data]
            # 仅仅返回前nun_data 维的数据才合理
            #  返回投影矩阵、方差和均值
        return V,S,mean_X
    
    def denoise(im,U_init,tolerance=0.1,tau=0.125,tv_weight=100):
        """ 使用A. Chambolle(2005)在公式(11)中的计算步骤实现Rudin-Osher-Fatemi(ROF)去噪模型
           输入:含有噪声的输入图像(灰度图像)、U 的初始值、TV 正则项权值、步长、停业条件
            输出:去噪和去除纹理后的图像、纹理残留"""
        m,n = im.shape # 噪声图像的大小
    
        #  初始化
        U = U_init
        Px = im # 对偶域的x 分量
        Py = im # 对偶域的y 分量
        error = 1
        while (error > tolerance):
            Uold = U
    
            # 原始变量的梯度
            GradUx = roll(U,-1,axis=1)-U # 变量U 梯度的x 分量
            GradUy = roll(U,-1,axis=0)-U # 变量U 梯度的y 分量
    
            #  更新对偶变量
            PxNew = Px + (tau/tv_weight)*GradUx
            PyNew = Py + (tau/tv_weight)*GradUy
            NormNew = maximum(1,sqrt(PxNew**2+PyNew**2))
            Px = PxNew/NormNew # 更新x 分量(对偶)
            Py = PyNew/NormNew # 更新y 分量(对偶)
            #  更新原始变量
            RxPx = roll(Px,1,axis=1) # 对x 分量进行向右x 轴平移
            RyPy = roll(Py,1,axis=0) # 对y 分量进行向右y 轴平移
    
            DivP = (Px-RxPx)+(Py-RyPy) # 对偶域的散度
            U = im + tv_weight*DivP # 更新原始变量
    
            #  更新误差
            error = linalg.norm(U-Uold)/sqrt(n*m);
        return U,im-U  # 去噪后的图像和纹理残余
    
    
    
    
    image_list = get_imlist("G:\\最后两种\\")
    
    index=6858
    for image_address in image_list:
        index = index + 1
        dealIndex=0
        for x in range(1,17):
            image = Image.open(image_address)
            imageArray = array(image)
            dealIndex+=1
            if x==1:
                # 反相处理
                imageArray = 255 - imageArray
                print("第"+str(index)+"张 反向处理")
            elif x==2:
                # 将图像像素值变换到100...200 区间
                imageArray = (100.0 / 255) * imageArray + 100
                print("第" + str(index) + "张 像素值变换")
            elif x==3:
                # 对图像像素值求平方后得到的图像
                imageArray = 255.0 * (imageArray / 255.0) ** 2
                print("第" + str(index) + "张 像素值求平方")
            elif x==4:
                # 图像旋转
                image = image.rotate(random.randint(0,360))
                imageArray=array(image)
                print("第" + str(index) + "张 图像旋转")
            elif x==5:
                # 直方图均衡化
                imageArray,cdf=histeq(imageArray)
                print("第" + str(index) + "张 直方图均衡化")
            elif x==6:
                # gaussian滤波
                imageArray = filters.gaussian_filter(imageArray, 5)
                print("第" + str(index) + "张 gaussian滤波")
            elif x==7:
                # Sobel 导数滤波器
                imx = zeros(imageArray.shape)
                filters.sobel(imageArray, 1, imx)
                imy = zeros(imageArray.shape)
                filters.sobel(imageArray, 0, imy)
                magnitude = sqrt(imx ** 2 + imy ** 2)
                imageArray=magnitude
                print("第" + str(index) + "张  Sobel导数滤波器")
            elif x==8:
                # 噪声
                imageArray = imageArray + 30 * random.standard_normal(imageArray.shape)
                print("第" + str(index) + "张  噪声")
            elif x==9:
                # 反相处理+像素值变换
                imageArray = 255 - imageArray
                imageArray = (100.0 / 255) * imageArray + 100
                print("第" + str(index) + "张  反相处理+像素值变换")
            elif x==10:
                # 反相处理+像素值求平方
                imageArray = 255 - imageArray
                imageArray = 255.0 * (imageArray / 255.0) ** 2
                print("第" + str(index) + "张  反相处理+像素值求平方")
            elif x==11:
                # 像素值求平方+反相处理
                imageArray = 255.0 * (imageArray / 255.0) ** 2
                imageArray = 255 - imageArray
                print("第" + str(index) + "张  像素值求平方+反相处理")
            elif x==12:
                # 像素值变换+像素值求平方
                imageArray = (100.0 / 255) * imageArray + 100
                imageArray = 255.0 * (imageArray / 255.0) ** 2
                print("第" + str(index) + "张  像素值变换+像素值求平方")
            elif x==13:
                # 图像旋转+反相
                image = image.rotate(random.randint(0, 360))
                imageArray = array(image)
                imageArray = 255 - imageArray
                print("第" + str(index) + "张  图像旋转+反相")
            elif x==14:
                # 图像旋转+噪声
                image = image.rotate(random.randint(0, 360))
                imageArray = array(image)
                imageArray = imageArray + 30 * random.standard_normal(imageArray.shape)
                print("第" + str(index) + "张  图像旋转+噪声")
            elif x==15:
                # 噪声+直方图均衡化
                imageArray = imageArray + 30 * random.standard_normal(imageArray.shape)
                imageArray, cdf = histeq(imageArray)
                print("第" + str(index) + "张  噪声+直方图均衡化")
    
    
            imageArray = uint8(imageArray)
            image=Image.fromarray(imageArray)
            image = image.convert('RGB')
            if image_address.rfind("不规则")!= -1:
                image.save("G:\\兔屎图片_二次处理\\不规则\\" + str(index)+"_"+str(dealIndex) + ".jpg")
            elif image_address.rfind("大小不一") != -1:
                image.save("G:\\兔屎图片_二次处理\\大小不一\\" + str(index) +"_"+str(dealIndex)+ ".jpg")
            elif image_address.rfind("拉稀") != -1:
                image.save("G:\\兔屎图片_二次处理\\拉稀\\" + str(index) +"_"+str(dealIndex)+ ".jpg")
            elif image_address.rfind("正常") != -1:
                image.save("G:\\兔屎图片_二次处理\\正常\\" + str(index) +"_"+str(dealIndex)+ ".jpg")
    
            print("完事一个")

    参考文章:https://www.cnblogs.com/xk-bench/p/7825290.html

    展开全文
  • 第 1 章 基本的图像操作和处理本章讲解操作和处理图像的基础知识,将通过大量...1.1 PIL:Python图像处理类库PIL(Python Imaging Library Python,图像处理类库)提供了通用的图像处理功能,以及大量有用的基本图...
  • python 图像处理

    2018-06-19 14:51:01
    转自:点击打开链接第 1 章 基本的图像操作和处理本章讲解操作和处理图像的基础知识,将通过大量...1.1 PIL:Python图像处理类库PIL(Python Imaging Library Python,图像处理类库)提供了通用的图像处理功能,以...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • python图像处理 (一).PIL图像处理库学习① 1、自定义创建图片 PIL除了可以从文件中打开一张图片,我们也可以创建一张图片 Image.new(mode,size) ⇒ image Image.new(mode, size,color) ⇒ image 创建具有给定...
  • Image模块是在Python PIL图像处理中常见的模块,对图像进行基础操作的功能基本都包含于此模块内。如open、save、conver、show…等功能。 open类 Image.open(file) ⇒ image Image.open(file, mode) ⇒ image...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • Python中进行图像处理可以使用的库有很多,本文主要介绍下面三个:OpenCV、PIL、 skimage。其中,OpenCV是图像处理中最强大的一个库,它的源代码是由C\C++写成的,所以原版的OpenCV可以与C、C++无缝结合。Python版...
  • Python 图像处理 OpenCV (1):入门」 「Python 图像处理 OpenCV (2):像素处理与 Numpy 操作以及 Matplotlib 显示图像」 「Python 图像处理 OpenCV (3):图像属性、图像感兴趣 ROI 区域及通道处理」 「...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • python作为机器学习和图像处理的利器,收到越来越多的推崇,特别是在图像处理领域,越来越多的研究和开发开始转向使用python语言,下面就介绍python图像处理中最基本的操作,即图像的读取显示与保存。
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • 前面一篇文章我讲解了基于K-Means聚类的图像分割或量化处理,但突然发现世面上的文章讲解图像量化和采样代码的很缺乏,因此结合2015年自己的一篇文章,补充相关知识供同学们学习。基础性文章,希望对你有所帮助。...
  • 图像的膨胀(Dilation)和腐蚀(Erosion)是两种基本的形态学运算,主要用来寻找图像中的极大区域和极小区域。其中膨胀类似于“领域扩张”,将图像中的高亮区域或白色部分进行扩张,其运行结果图比原图的高亮区域更...
  • 图像处理那首先要配个环境嘛,配环境真的是我长久以来的噩梦了,每次都会出现奇奇怪怪的问题,首先上网查找了一下,opencv这个库还是用的比较多的,如果想要使用C++来做图像处理的话,那么使用visual studio搭配...
1 2 3 4 5 ... 20
收藏数 119,064
精华内容 47,625
关键字:

python的图像处理