• 最近需要学习python图像处理方法,在这里简单的总结一下自己学到的一些图像处理的方法把~ 1.Python PIL库读取图像 import PIL from PIL import Image im = Image.open(filepath) 2.简单进行图像旋转 out = ...

    最近需要学习python的图像处理方法,在这里简单的总结一下自己学到的一些图像处理的方法把~

    1.Python PIL库读取图像

    import PIL
    from PIL import Image
    
    im = Image.open(filepath)

    2.简单进行图像旋转

    out = im.rotate(270) #这里输入的是旋转角度
    out = im.transpose(Image.ROTATE_270)

    3.在PIL中还可以吧RGB图像的R,G,B分离出来使用的呢;例如:

    r,g,b = im.spilt()
    im = Image.merge("RGB",(r,b,g))
    #这样R,G,B就调换成了R,B,G来使用了,也就是说B的值当R来使用这个意思
    4、图像增强,可以增强一下对比度
    from PIL import ImageEnhance as ie
    enh = ie.Contrast(image)
    enh.enhance(1.3).show("30% enhance")

    5、利用Image模块还可以创建thumnail

    import glob
    for infile in glob.glob("*.jpg"):
        file, ext = os.splitext(infile)
        im = Image.open(infile)
        im.thumbnail((128, 128), Image.ANTIALIAS)
        im.save(file + ".thumbnail", "JPEG")
    

    下面来介绍一下Image模块下的一些函数:

    1=》Image.new(mode,size)/Image.new(mode,size,color)

    这个是新创建一张图片

    2=》Image.open(infile)/Image.open(infile,mode)

    这个是打开一张图片,打开的这张图片呢,在你对这张图片进行操作之前是不会读取进来的,在你进行操作的时候就读进来

    如果指定了mode的话,那一定是“r“

    3=》Image.blend(image1,image2,alpha)

    out = image * (1-alpha) + image2 * alpha

    看看out你就知道了什么意思了,当alpha是0时,输出的就是image1,当alpha是1时,输出的就是image2

    但是两个图像的大小需要一致的

    4=》Image.composite(image1,image2,mask)

    利用mask当做是alpha,创建一张在image1,image2之间的新图像

    5=》Image.eval(function,image)

     

    6=>Image.fromstring(mode,size,data)/Image.fromstring(mode,size,data,decoder,parameters)

    对于第一个,就是从一个string中的像素数据中创建图像,使用的解码器是”raw“;第二个就是自选decoder了

    7=>Image.merge(mode,bands)

     

     

     

    展开全文
  • Python做图像处理

    2008-01-18 12:11:00
    Python做图像处理 最近在一件比较 evil 的事情——验证码识别,以此来学习一些新的技能。因为我是初学,对图像处理方面就不太了解了,欲要利吾事,必先利吾器,既然只是一下实验,那用 Python 来作原型开发再...
    用Python做图像处理
    id="alimamaifrm" style="WIDTH: 750px; HEIGHT: 110px" border="0" name="alimamaifrm" marginwidth="0" marginheight="0" src="http://p.alimama.com/cpacode.php?t=A&pid=mm_10108440_0_0&w=750&h=110&rn=1&cn=3&ky=&cid=251602&bgc=FFFFFF&bdc=E6E6E6&tc=0000FF&dc=000000" frameborder="0" width="750" scrolling="no" height="110">
           最近在做一件比较 evil 的事情——验证码识别,以此来学习一些新的技能。因为我是初学,对图像处理方面就不太了解了,欲要利吾事,必先利吾器,既然只是做一下实验,那用 Python 来作原型开发再好不过了。在 Python 中,比较常用的图像处理库是 PIL(Python Image Library),当前版本是 1.1.6 ,用起来非常方便。大家可以在 http://www.pythonware.com/products/pil/index.htm 下载和学习。
           在这里,我主要是介绍一下做图像识别时可能会用到的一些 PIL 提供的功能,比如图像增强、还有滤波之类的。最后给出使用 Python 做图像处理与识别的优势与劣势。
    基本图像处理
           使用 PIL 之前需要 import Image 模块:
    import Image
           然后你就可以使用Image.open(‘xx.bmp’) 来打开一个位图文件进行处理了。打开文件你不用担心格式,也不用了解格式,无论什么格式,都只要把文件名丢给 Image.open 就可以了。真所谓 bmp、jpg、png、gif……,一个都不能少。
    img = Image.open(‘origin.png’)    # 得到一个图像的实例对象 img
    1原图
           图像处理中,最基本的就是色彩空间的转换。一般而言,我们的图像都是 RGB 色彩空间的,但在图像识别当中,我们可能需要转换图像到灰度图、二值图等不同的色彩空间。 PIL 在这方面也提供了极完备的支持,我们可以:
    new_img = img.convert(‘L’)
    把 img 转换为 256 级灰度图像, convert() 是图像实例对象的一个方法,接受一个 mode 参数,用以指定一种色彩模式,mode 的取值可以是如下几种:
    · 1 (1-bit pixels, black and white, stored with one pixel per byte)
    · L (8-bit pixels, black and white)
    · P (8-bit pixels, mapped to any other mode using a colour palette)
    · RGB (3x8-bit pixels, true colour)
    · RGBA (4x8-bit pixels, true colour with transparency mask)
    · CMYK (4x8-bit pixels, colour separation)
    · YCbCr (3x8-bit pixels, colour video format)
    · I (32-bit signed integer pixels)
    · F (32-bit floating point pixels)
    怎么样,够丰富吧?其实如此之处,PIL 还有限制地支持以下几种比较少见的色彩模式:LA (L with alpha), RGBX (true colour with padding) and RGBa (true colour with premultiplied alpha)。
    下面看一下 mode 为 ‘1’、’L’、’P’时转换出来的图像:
    2 mode = '1'
    3 mode = 'L'
    4 mode = 'P'
    convert() 函数也接受另一个隐含参数 matrix,转换矩阵 matrix 是一个长度为4 或者16 tuple。下例是一个转换 RGB 空间到 CIE XYZ 空间的例子:
        rgb2xyz = (
            0.412453, 0.357580, 0.180423, 0,
            0.212671, 0.715160, 0.072169, 0,
            0.019334, 0.119193, 0.950227, 0 )
        out = im.convert("RGB", rgb2xyz)
           除了完备的色彩空间转换能力外, PIL 还提供了resize()、rotate()等函数以获得改变大小,旋转图片等几何变换能力,在图像识别方面,图像实例提供了一个 histogram() 方法来计算直方图,非常方便实用。
    图像增强
           图像增强通常用以图像识别之前的预处理,适当的图像增强能够使得识别过程达到事半功倍的效果。 PIL 在这方面提供了一个名为 ImageEnhance 的模块,提供了几种常见的图像增强方案:
    import ImageEnhance
    enhancer = ImageEnhance.Sharpness(image)
    for i in range(8):
        factor = i / 4.0
        enhancer.enhance(factor).show("Sharpness %f" % factor)
    上面的代码即是一个典型的使用 ImageEnhance 模块的例子。 Sharpness 是 ImageEnhance 模块的一个类,用以锐化图片。这一模块主要包含如下几个类:Color、Brightness、Contrast和Sharpness。它们都有一个共同的接口 .enhance(factor) ,接受一个浮点参数 factor,标示增强的比例。下面看看这四个类在不同的 factor 下的效果
    5 使用Color 进行色彩增强,factor 取值 [0, 4],步进 0.5
    6 用 Birghtness 增强亮度,factor取值[0,4],步进0.5
    7用 Contrast 增强对比度, factor 取值 [0,4],步进0.5
    8用 Sharpness 锐化图像,factor取值 [0,4],步进0.5
    图像 Filter
           PIL 在 Filter 方面的支持是非常完备的,除常见的模糊、浮雕、轮廓、边缘增强和平滑,还有中值滤波、ModeFilter等,简直方便到可以做自己做一个Photoshop。这些 Filter 都放置在 ImageFilter 模块中,ImageFilter主要包括两部分内容,一是内置的 Filter,如 BLUR、DETAIL等,另一部分是 Filter 函数,可以指定不同的参数获得不同的效果。示例如下:
    import ImageFilter
    im1 = im.filter(ImageFilter.BLUR)
    im2 = im.filter(ImageFilter.MinFilter(3))
    im3 = im.filter(ImageFilter.MinFilter()) # same as MinFilter(3)
    可以看到 ImageFilter 模块的使用非常简单,每一个 Filter 都只需要一行代码就可调用,开发效率非常高。
     
    9使用 BLUR
    10使用 CONTOUR
    11使用 DETAIL
    12使用 EMBOSS
    13使用 EDGE_ENHANCE
    14使用 EDGE_ENHANCE_MORE
    15使用 FIND_EDGES
    16使用 SHARPEN
    17使用 SMOOTH
    18使用 SMOOTH_MORE
           以上是几种内置的 Filter 的效果图,除此之外, ImageFilter 还提供了一些 Filter 函数,下面我们来看看这些可以通过参数改变行为的 Filter 的效果:
    19使用 Kernel(),参数:size = (3, 3), kernel = (0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5)
    20使用 MaxFilter,默认参数
    21使用 MinFilter,默认参数
    22使用 MedianFilter,默认参数
    23使用 ModeFilter,参数 size = 3
    24使用 RankFilter,参数 size = 3, rank = 3
    小结
           到此,对 PIL 的介绍就告一段落了。总的来说,对于图像处理和识别,PIL 内建了强大的支持,从各种增强算法到 Filter ,都让人无法怀疑使用 Python 的可行性。 Python唯一的劣势在于执行时间过慢,特别是当实现一些计算量大的算法时候,需要极强的耐心。我曾用 Hough Transform(霍夫变换)来查找图像中的直线,纯 Python 的实现处理一个 340 * 100 的图片也要花去数秒时间(P4 3.0G + 1G memory)。但使用 PIL 无需关注图像格式、内建的图像增强算法和 Filter 算法,这些优点使 Python 适合用于构造原型和进行实验,在这两方面Python 比 matlab 更加方便。商业的图像识别产品开发,可以考虑已经被 boost accepted的来自 adobe 的开源 C++ 库 gil,可以兼顾执行性能和开发效率。
    id="alimamaifrm" style="WIDTH: 750px; HEIGHT: 110px" border="0" name="alimamaifrm" marginwidth="0" marginheight="0" src="http://p.alimama.com/cpacode.php?t=A&pid=mm_10108440_0_0&w=750&h=110&rn=1&cn=3&ky=%CA%E9&cid=50000072&bgc=FFFFFF&bdc=E6E6E6&tc=0000FF&dc=000000" frameborder="0" width="750" scrolling="no" height="110">
    展开全文
  • 提到图像处理第一个想到的库就是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

    展开全文
  • 目录 ...初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值化等特性非常头疼,这里给各位分享一个小项目,可通过摄像头实时动态查看各类图像处理的特点,也可对各位调参、测试...

    目录

    1、导入库文件

    2、设计GUI

    3、调用摄像头

    4、实时图像处理

    4.1、阈值二值化

    4.2、边缘检测

    4.3、轮廓检测

    4.4、高斯滤波

    4.5、色彩转换

    4.6、调节对比度

    5、退出系统


    初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值化等特性非常头疼,这里给各位分享一个小项目,可通过摄像头实时动态查看各类图像处理的特点,也可对各位调参、测试有一定帮助,项目演示效果如下:

    1、导入库文件

    这里主要使用PySimpleGUI、cv2和numpy库文件,PySimpleGUI库文件实现GUI可视化,cv2库文件是Python的OpenCV接口文件,numpy库文件实现数值的转换和运算,均可通过pip导入。

    import PySimpleGUI as sg  #pip install pysimplegui
    import cv2  #pip install opencv-python
    import numpy as np #pip install numpy

    2、设计GUI

    基于PySimpleGUI库文件实现GUI设计,本项目界面设计较为简单,设计800X400尺寸大小的框图,浅绿色背景,主要由摄像头界面区域和控制按钮区域两部分组成。效果如下所示:

    GUI代码如下所示:

        #背景色
        sg.theme('LightGreen')
    
        #定义窗口布局
        layout = [
          [sg.Image(filename='', key='image')],
          [sg.Radio('None', 'Radio', True, size=(10, 1))],
          [sg.Radio('threshold', 'Radio', size=(10, 1), key='thresh'),
           sg.Slider((0, 255), 128, 1, orientation='h', size=(40, 15), key='thresh_slider')],
          [sg.Radio('canny', 'Radio', size=(10, 1), key='canny'),
           sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='canny_slider_a'),
           sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='canny_slider_b')],
          [sg.Radio('contour', 'Radio', size=(10, 1), key='contour'),
           sg.Slider((0, 255), 128, 1, orientation='h', size=(20, 15), key='contour_slider'),
           sg.Slider((0, 255), 80, 1, orientation='h', size=(20, 15), key='base_slider')],
          [sg.Radio('blur', 'Radio', size=(10, 1), key='blur'),
           sg.Slider((1, 11), 1, 1, orientation='h', size=(40, 15), key='blur_slider')],
          [sg.Radio('hue', 'Radio', size=(10, 1), key='hue'),
           sg.Slider((0, 225), 0, 1, orientation='h', size=(40, 15), key='hue_slider')],
          [sg.Radio('enhance', 'Radio', size=(10, 1), key='enhance'),
           sg.Slider((1, 255), 128, 1, orientation='h', size=(40, 15), key='enhance_slider')],
          [sg.Button('Exit', size=(10, 1))]
        ]
    
        #窗口设计
        window = sg.Window('OpenCV实时图像处理',
                   layout,
                   location=(800, 400),
                   finalize=True)

    3、调用摄像头

    打开电脑内置摄像头,将数据显示在GUI界面上,效果如下所示:

    代码如下所示:

        #打开内置摄像头
        cap = cv2.VideoCapture(0)
        while True:
            event, values = window.read(timeout=0, timeout_key='timeout')
    
            #实时读取图像
            ret, frame = cap.read()
    
            #GUI实时更新
            imgbytes = cv2.imencode('.png', frame)[1].tobytes()
            window['image'].update(data=imgbytes)
    
        window.close()

    4、实时图像处理

    4.1、阈值二值化

    进行阈值二值化操作,大于阈值values['thresh_slider']的,使用255表示,小于阈值values['thresh_slider']的,使用0表示,效果如下所示:

     代码如下所示:

    if values['thresh']:
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)[:, :, 0]
        frame = cv2.threshold(frame, values['thresh_slider'], 255, cv2.THRESH_BINARY)[1]

    4.2、边缘检测

    进行边缘检测,values['canny_slider_a']表示最小阈值,values['canny_slider_b']表示最大阈值,效果如下所示:

    代码如下所示:

    if values['canny']:
        frame = cv2.Canny(frame, values['canny_slider_a'], values['canny_slider_b'])

    4.3、轮廓检测

    轮廓检测是形状分析和物体检测和识别的有用工具,连接所有连续点(沿着边界)的曲线,具有相同的颜色或强度,效果如下所示:

     代码如下所示:

    if values['contour']:
        hue = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        hue = cv2.GaussianBlur(hue, (21, 21), 1)
        hue = cv2.inRange(hue, np.array([values['contour_slider'], values['base_slider'], 40]),
                          np.array([values['contour_slider'] + 30, 255, 220]))
        cnts= cv2.findContours(hue, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[0]
        cv2.drawContours(frame, cnts, -1, (0, 0, 255), 2)
    

    4.4、高斯滤波

    进行高斯滤波,(21, 21)表示高斯矩阵的长与宽都是21,标准差取values['blur_slider'],效果如下所示:

     代码如下所示:

    if values['blur']:
        frame = cv2.GaussianBlur(frame, (21, 21), values['blur_slider'])
    

    4.5、色彩转换

    色彩空间的转化,HSV转换为BGR,效果如下所示:

     代码如下所示:

    if values['hue']:
        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
        frame[:, :, 0] += int(values['hue_slider'])
        frame = cv2.cvtColor(frame, cv2.COLOR_HSV2BGR)

    4.6、调节对比度

    增强对比度,使图像中的细节看起来更加清晰,效果如下所示:

      代码如下所示:

    if values['enhance']:
        enh_val = values['enhance_slider'] / 40
        clahe = cv2.createCLAHE(clipLimit=enh_val, tileGridSize=(8, 8))
        lab = cv2.cvtColor(frame, cv2.COLOR_BGR2LAB)
        lab[:, :, 0] = clahe.apply(lab[:, :, 0])
        frame = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
    

    5、退出系统

    直接break即可跳出循环。

    if event == 'Exit' or event is None:
        break

    拓展学习:基于Python的人工智能美颜系统 

    请关注公众号,回复关键字:OpenCV实时图像处理,获取项目资源。

    展开全文
  • Python中进行图像处理可以使用的库有很多,本文主要介绍下面三个:OpenCV、PIL、 skimage。其中,OpenCV是图像处理中最强大的一个库,它的源代码是由C\C++写成的,所以原版的OpenCV可以与C、C++无缝结合。Python版...

    在Python中进行图像处理可以使用的库有很多,本文主要介绍下面三个:

    • OpenCV(Open Source Computer Vision Library)
    • PIL(Python Imaging Library)
    • skimage(scikit-image)

    *如下代码的实验环境为Jupyter Notebook.

    欢迎关注白马负金羁的博客 http://blog.csdn.net/baimafujinji,为保证公式、图表得以正确显示,强烈建议你从该地址上查看原版博文。本博客主要关注方向包括:数字图像处理、算法设计与分析、数据结构、机器学习、数据挖掘、统计分析方法、自然语言处理。


    1. OpenCV

    OpenCV是图像处理中最强大的一个库,它的源代码是由C\C++写成的,所以原版的OpenCV可以与C、C++无缝结合。Python版的OpenCV主要依赖于cv2这个包来实现。

    1.1  imread()

    import cv2
    import numpy as np
    
    #读入图片:默认彩色图,cv2.IMREAD_GRAYSCALE灰度图,cv2.IMREAD_UNCHANGED包含alpha通道
    img = cv2.imread('Lena.png')
    print(img.shape)
    print(type(img))

    上述代码的执行结果如下:

    (512, 512, 3)
    <class 'numpy.ndarray'>
    

    此时,被读入的图像以ndarray格式存在,取值范围是 [0, 255]。

    1.2  imshow()

    cv2.imshow('Lena',img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

    函数imshow()用于显示图像,但只使用它并不会得到任何结果,必须结合后面的waitKey(delay),参数delay表示延迟多少毫秒。默认情况为0。当delay≤0,可以理解为延迟无穷大毫秒。调用destroyAllWindows()函数可以释放由 OpenCV创建的所有窗口。注意上面三条语句必须写在Jupyter notebook中的同一Cell里,然后按任意键,系统会关闭图像显示窗口。

    1.3  imwrite()

    cv2.imwrite('lena.jpg',img)

    函数imwrite()用于存储图像,第一个参数是file name,第二个参数是要存储的图像对象。

     

    参考链接【点击链接】

    欢迎关注白马负金羁的博客 http://blog.csdn.net/baimafujinji,为保证公式、图表得以正确显示,强烈建议你从该地址上查看原版博文。本博客主要关注方向包括:数字图像处理、算法设计与分析、数据结构、机器学习、数据挖掘、统计分析方法、自然语言处理。


    2. PIL

    Python里面自带一个PIL(python images library), 但这个库现在已经停止更新了,所以使用Pillow, 它是由PIL发展而来的。

    1.1  open()

    from PIL import Image
    import numpy as np
    
    img = Image.open('Lena.png')
    print(img.size)
    print(img.mode)
    print(type(img))

    上述代码的执行结果如下:

    (512, 512)
    RGB
    <class 'PIL.PngImagePlugin.PngImageFile'>
    

    1.2 show()

    下面的代码可以用来显示图像,程序会弹出一个单独的图像窗口。

    img.show()

    除此之外,还可以使用matplotlib来绘制图像,它是一个专业绘图的库,相当于matlab中的plot,可以设置多个figure,设置figure的标题,甚至可以使用subplot在一个figure中显示多张图片。

    import matplotlib.pyplot as plt
    %matplotlib inline
    
    plt.imshow(img)

    inline一句的作用是在Jupyter Notebook的网页中直接绘图,即不会单独弹出绘图窗口,上述代码的执行结果如下:

    如果不希望显示坐标轴,则可以使用下面的代码:

    plt.axis('off')
    plt.imshow(img)

    下面的代码演示了显示多行、多列图像的方法,注意其中显示灰度图像的语法。

    fig=plt.figure(figsize=(28, 28))
    columns = 5
    rows = 5
    for i in range(1, columns*rows +1):
        img = test_only_success_adv[650+i].reshape(28,28)+0.5
        fig.add_subplot(rows, columns, i)
        plt.imshow(img, cmap='gray')
        plt.axis('off')

    代码执行结果如下:

    1.3  save()

    图像保存可以使用:

    img.save('lena2.jpg')

    如果要把以ndarray格式存储的矩阵保存成图像,则需要使用:

    im = Image.fromarray(np.uint8(data_jsma_0*255))
    im.save("000.png")

     

    参考链接【点击链接】

    欢迎关注白马负金羁的博客 http://blog.csdn.net/baimafujinji,为保证公式、图表得以正确显示,强烈建议你从该地址上查看原版博文。本博客主要关注方向包括:数字图像处理、算法设计与分析、数据结构、机器学习、数据挖掘、统计分析方法、自然语言处理。


    3. skimage

     

    1.1  imread()

    参考示例代码:

    from skimage import io
    import numpy as np
    
    img = io.imread('Lena.png')
    print(img.shape) # numpy矩阵,(h,w,c)
    
    print(type(img))

    上述代码执行结果如下:

    (512, 512, 3)
    <class 'numpy.ndarray'>
    

    被读入的图像以ndarray格式存在。

    与之前类似,io.imshow() 和 io.imsave() 分别用于显示和存储图像。

    1.2  img_as_ubyte()

    该函数的作用是convert an image to 8-bit unsigned integer format,也就是把图像像素灰度的取值范围转化到0~255之间的整数。

    例如,

    print(np.max(adv_test_cw0[0]))
    print(np.min(adv_test_cw0[0]))
    
    byte_adv_test_cw0 = img_as_ubyte(adv_test_cw0)
    
    print(np.max(byte_adv_test_cw0[0]))
    print(np.min(byte_adv_test_cw0[0]))

    上述代码的执行结果如下:

    0.9997719
    0.00054621696

    255
    0

     

    参考链接【点击链接】

     

    欢迎关注白马负金羁的博客 http://blog.csdn.net/baimafujinji,为保证公式、图表得以正确显示,强烈建议你从该地址上查看原版博文。本博客主要关注方向包括:数字图像处理、算法设计与分析、数据结构、机器学习、数据挖掘、统计分析方法、自然语言处理。

    【全文完】

    展开全文
  • 第 1 章 基本的图像操作和处理本章讲解操作和处理图像的基础知识,将通过大量...1.1 PIL:Python图像处理类库PIL(Python Imaging Library Python,图像处理类库)提供了通用的图像处理功能,以及大量有用的基本图...
  • 前面一篇文章我讲解了Python图像量化、采样处理及图像金字塔。本文主要讲解图像傅里叶变换的相关内容,在数字图像处理中,有两个经典的变换被广泛应用——傅里叶变换和霍夫变换。其中,傅里叶变换主要是将时间域上的...
  • Python中的图像处理

    2018-03-03 22:27:15
    第 1 章 基本的图像操作和处理本章讲解操作和处理图像的基础知识,将通过大量...1.1 PIL:Python图像处理类库PIL(Python Imaging Library Python,图像处理类库)提供了通用的图像处理功能,以及大量有用的基本图...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • PIL(Python Imaging Library),是Python平台上的图像处理标准库。功能非常强大,API却简单易用。 由于PIL仅支持到Python2.7,加上年久失修,于是一群志愿者在PIL的基础上创建了兼容的版本,名叫Pillow,支持最新...
  • Python数字图像处理

    2017-06-22 20:18:26
    转:宁静家园python数字图像处理(1):环境安装和配置python数字图像处理(2):图像的读取、显示与保存python数字图像处理3):图像像素的访问与裁剪python数字图像处理(4):图像数据类型及颜色空间转换python...
  • python 图像处理

    2018-06-19 14:51:01
    转自:点击打开链接第 1 章 基本的图像操作和处理本章讲解操作和处理图像的基础知识,将通过大量...1.1 PIL:Python图像处理类库PIL(Python Imaging Library Python,图像处理类库)提供了通用的图像处理功能,以...
  • 这些Python库提供了一种简单直观的方法来转换图像并理解底层数据。 今天的世界充满了数据,图像是这些数据的重要组成部分。但是,在使用它们之前,必须...Python是这些图像处理任务的绝佳选择,因为它作为一种科学...
  • 该系列文章是讲解Python OpenCV图像处理知识,前期主要讲解图像入门、OpenCV基础用法,中期讲解图像处理的各种算法,包括图像锐化算子、图像增强技术、图像分割等,后期结合深度学习研究图像识别、图像分类应用。...
  • python中利用numpy库和scipy库来进行各种数据操作和科学计算。...以后,只要是在python中进行数字图像处理,我们都需要导入这些包: from PIL import Image import numpy as np import matplotlib.pyplot as...
  • python数字图像处理

    2018-09-12 20:03:41
    这里博客是自己的个系统整理,主要说的是python在数字图像处理方面的应用,主要用到的库有PIL和skimage PIL库 1、用python简单处理图片:打开、显示、保存图像 2、用python简单处理图片:图像通道、几何变换...
  • 本篇博客将介绍 读取、显示、保存图像,读取、修改 像素值(openCV 与 numpy) 三个部分。
  • 所以,在做图像处理之前,我们需要考虑清楚自己要基于哪种格式的图像进行算法设计及其实现。本文基于这个需求,使用python中的图像处理库PIL来实现不同图像格式的转换。 对于彩色图像,不管其图像格式是PNG,还是...
1 2 3 4 5 ... 20
收藏数 116,364
精华内容 46,545
关键字:

python3做图像处理