大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

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

提到图像处理第一个想到的库就是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("完事一个")

如何用python做图像处理_python判断窗口是否存在