(超全)python图像处理详细解析（2）

15.对图片进行二值化

from skimage import io,data,color
img=io.imread('iii.jpg')
#将彩色图像转换为灰度图像
img_gray=color.rgb2gray(img)
#获取灰度图像的行数和列数
rows,cols=img_gray.shape
#对图像的每一行进行迭代。
for i in range(rows):
#对图像的每一列进行迭代。
for j in range(cols):
#检查当前像素的灰度值是否小于等于0.5。
        if (img_gray[i,j]<=0.5):
#如果是，将当前像素的值设置为0。
            img_gray[i,j]=0
        else:
            img_gray[i,j]=1
io.imshow(img_gray)
#使用了color模块的rgb2gray（）函数，将彩色三通道图片转换成灰度图。转换结果为float64类型的数组，范围为[0,1]之间。

16.图像归一化

1、线性归一化：将图像的像素值线性映射到[0, 1]范围内。这是最常见的归一化方法，也是最简单的方法之一。

normalized_image = (image - np.min(image)) / (np.max(image) - np.min(image))

2、均值方差归一化：将图像的像素值减去均值后，除以标准差，使得图像的均值为0，标准差为1。这样可以降低图像数据的偏差和差异性。
代码如下：

import numpy as np
#image为array类型，多少维度都无所谓，直接操作全部元素
image = (image - np.min(image)) / (np.max(image) - np.min(image))

3、直方图均衡化：通过重新分布图像像素的直方图，增强图像的对比度和细节。这在图像增强和图像识别等领域非常有用。

from skimage import exposure
equalized_image = exposure.equalize_hist(image)

三、图像归一化的应用场景
计算机视觉：在计算机视觉中，图像归一化可以用于预处理图像数据，以提高分类、检测和识别算法的准确性和稳定性。
图像增强：通过归一化，我们可以增强图像的对比度、亮度和细节，使图像更加清晰和鲜明。
图像分析：在图像分析中，图像归一化可以帮助我们去除图像之间的差异，使得图像数据更易于比较和分析。

from skimage import io, color
import numpy as np

# 读取图像
image = io.imread('image.jpg')

# 获取图像的像素值范围
min_val = np.min(image)
max_val = np.max(image)

# 归一化图像
normalized_image = (image - min_val) / (max_val - min_val)

# 显示归一化后的图像
io.imshow(normalized_image)
io.show()

17.阈值分割

1.

from skimage import io,data
img=io.imread('iii.jpg')
#其中对于图像中的每个像素，如果红色通道的值大于170，则对应位置为True，否则为False。
reddish = img[:, :, 0] >170
# 将图像中红色通道值大于170的像素改为纯红色，即将红色通道设为255，绿色通道和蓝色通道设为0。
img[reddish] = [255, 0, 0]
io.imshow(img)

2.

from skimage import io,data
img=io.imread('iii.jpg')
reddish = img[:, :, 0] >170
#图像中红色通道值大于170的像素改为纯绿色，即将红色通道和蓝色通道设为0，绿色通道设为255。
img[reddish] = [0,255, 0]
io.imshow(img)

3.

from skimage import io,data
img=io.imread('iii.jpg')
reddish = img[:, :, 0] >170
#将图像中红色通道值大于170的像素改为纯蓝色，即将红色通道和绿色通道设为0，蓝色通道设为255。
img[reddish] = [0, 0, 255]
io.imshow(img)

4.

from skimage import io,data
img=io.imread('iii.jpg')
#对于图像中的每个像素，如果绿色通道的值大于170，则对应位置为True，否则为False。
reddish = img[:, :, 1] >170
#将图像中绿色通道值大于170的像素改为灰色，即将红色、绿色和蓝色通道的值都设为50。
img[reddish] = [50, 50, 50]
io.imshow(img)

18.图像数据类型及转换

在skimage中，一张图片就是一个简单的numpy数组，数组的数据类型有很多种，相互之间也可以转换。这些数据类型及取值范围如下表所示：

Data type	Range
uint8	0 to 255
uint16	0 to 65535
uint32	0 to 232
float	-1 to 1 or 0 to 1
int8	-128 to 127
int16	-32768 to 32767
int32	-231 to 231 - 1

#从scikit-image库中导入io和data模块，这些模块包含了图像I/O和一些示例图像的功能。
from skimage import io,data
#导入PyTorch库，用于深度学习任务。
import torch
#从scikit-image库中导入resize函数，用于调整图像大小。
from skimage.transform import resize
#从matplotlib库中导入pyplot模块，用于绘制图像和图表。
from matplotlib import pyplot as plt
#读取图像
img=io.imread('iii.jpg')
#使用resize函数将图像大小调整为(200, 200)
img = resize(img,(200,200))
# print("Before normalize: \n",img)

#建立画布
#创建一个新的图形窗口。
fig = plt.figure()
#在图形窗口中添加一个子图，1行2列的布局，当前子图为第1个。
a=fig.add_subplot(1,2,1)
#显示调整大小后的图像img。
plt.imshow(img)
a.set_title('Before')
#打印图像数据类型的名称
print(img.dtype.name)

#定义一个包含均值的列表，用于归一化图像数据。
mean=[0.485, 0.456, 0.406]
#定义一个包含标准差的列表，用于归一化图像数据。
std=[0.229, 0.224, 0.225]

#将图像数据img转换为PyTorch的FloatTensor类型。
img = torch.FloatTensor(img)
#创建一个与图像大小相同的张量，其中每个像素的均值都设置为mean
mean = torch.FloatTensor(200*[200*[mean]])
#创建一个与图像大小相同的张量，其中每个像素的标准差都设置为std
std = torch.FloatTensor(200*[200*[std]])
#对图像数据进行归一化处理，即减去均值mean并除以标准差std。
img = (img - mean) / std

# print("After normalize: \n",img)
#在图形窗口中添加一个子图，1行2列的布局，当前子图为第2个。
a = fig.add_subplot(1, 2, 2)
#设置当前子图的标题为'After'。
a.set_title("After")
plt.imshow(img)
plt.show() 

1.unit8转float

from skimage import io, img_as_float

img = io.imread('mao.jpg')
print(img.dtype.name)
# print(img)
#将图像img转换为浮点数类型，并将结果存储在变量dst中。
dst = img_as_float(img)
print(dst.dtype.name)

io.imshow(dst)
#显示转换后的浮点数类型图像dst。
# print(dst)

2.float转unit8

from skimage import io,data,img_as_ubyte
import numpy as np
#创建一个包含0、0.5和1的NumPy数组，数据类型为浮点数。
img = np.array([0,0.5,1],dtype=float)
# io.imshow(img)
print(img.dtype.name)
print(img)
#将浮点数数组img转换为无符号字节类型，并将结果存储在变量dst1中。
dst1=img_as_ubyte(img)
print(dst1.dtype.name)
print(dst1)

19.颜色空间及其转换

除了直接转换可以改变数据类型外，还可以通过图像的颜色空间转换来改变数据类型。
常用的颜色空间有灰度空间、rgb空间、hsv空间和cmyk空间。颜色空间转换以后，图片类型都变成了float型。
所有的颜色空间转换函数，都放在skimage的color模块内。
RGB颜色空间有：(红red 绿green 蓝blue)三原色：取值范围都是：[0,255],[0,255],[0,255]
HSV：
H (Hue)色相:[0,360]
S (Saturation)饱和度，即色彩纯净度，0饱和度为白色
V (Value/Brightness):明度 0明度为纯黑色
在OpenCV中，颜色范围：
H = [0,179]
S = [0,255]
V = [0,255]
Lab：颜色之间的欧式距离有具体含义–距离越大，人眼感官两种颜色差距越远
L 通道：像素亮度，上白下黑 中间灰
a 通道：左绿 右红
b 通道：一端纯蓝，一端纯黄

rgb转灰度图：

from skimage import io, color
img = io.imread('mao.jpg')
gray_img = color.rgb2hsv(img)
io.imshow(gray_img)

其他转换：

rgb转hsv

用一个函数来代替上面的函数

skimage.color.convert_colorspace(arr, fromspace, tospace)
其中tospace必须是dict_key之一（[‘rgb’，‘hsv’，‘rgb-cie’，‘xyz’，‘yuv’，‘yiq’，‘ypbpr’，‘ycbcr’，‘ydbdr’]）

表示将img从RGB颜色空间转换到yuv颜色空间。

from skimage import io, color
img = io.imread('mao.jpg')
hsv=color.convert_colorspace(img,'RGB','yuv')
io.imshow(hsv)

对图片着色

将图片分成三类，然后用默认颜色对三类进行着色

from skimage import io, color
import numpy as np
img = io.imread('mao.jpg')
gray = color.rgb2hsv(img)  #颜色空间转换
rows,cols=gray.shape[0],gray.shape[1]  #提取行数（高度）和列数（宽度）
#创建了一个与图像大小相同的零数组labels，用于存储后续的标签信息。
labels=np.zeros([rows,cols])

for i in range(rows):
    for j in range(cols):
        if(gray[i,j,2]<0.4):
            labels[i,j]=1  #如果亮度小于0.4，标签被设置为1
        elif(gray[i,j,2]<0.75):
            labels[i,j]=1  #如果亮度小于0.75，标签也被设置为1
        else:
            labels[i,j]=2  #否则，标签被设置为2
#将标签数组转换为彩色图像，将不同的标签值转换为不同的颜色，通常用于可视化图像分割的结果。

dst=color.label2rgb(labels)  
io.imshow(dst)

20. imshow()图像的绘制

imshow()函数格式为：
matplotlib.pyplot.imshow(X, cmap=None)
X: 要绘制的图像或数组。
图像数据。支持的数组形状是：
（M，N） ：带有标量数据的图像。数据可视化使用色彩图。
（M，N，3） ：具有RGB值的图像（float或uint8）。
（M，N，4） ：具有RGBA值的图像（float或uint8），即包括透明度。
前两个维度（M，N）定义了行和列图片，即图片的高和宽；
RGB（A）值应该在浮点数[0, …, 1]的范围内,或者
整数[0, … ,255]。超出范围的值将被剪切为这些界限。

cmap: 颜色图谱（colormap), 默认绘制为RGB(A)颜色空间。

颜色图谱	描述
autumn	红-橙-黄
bone	黑-白，x线
cool	青-洋红
copper	黑-铜
flag	红-白-蓝-黑
gray	黑-白
hot	黑-红-黄-白
hsv	hsv颜色空间， 红-黄-绿-青-蓝-洋红-红
inferno	黑-红-黄
jet	蓝-青-黄-红
magma	黑-红-白
pink	黑-粉-白
plasma	绿-红-黄
prism	红-黄-绿-蓝-紫-…-绿模式
spring	洋红-黄
summer	绿-黄
viridis	蓝-绿-黄
winter	蓝-绿

import matplotlib.pyplot as plt
img = io.imread('mao.jpg')
plt.imshow(img,cmap=plt.cm.bone)

上图类型显示matplotlib.image.AxesImage，显示一张图片，我们还可以这样写：

import matplotlib.pyplot as plt
from skimage import io,data
img=io.imread('mao.jpg')
plt.imshow(img)
plt.show()

matplotlib是一个专业绘图的库，相当于matlab中的plot,可以设置多个figure窗口,设置figure的标题，隐藏坐标尺，甚至可以使用subplot在一个figure中显示多张图片。

21.用figure函数和subplot函数分别创建主窗口与子图

在图片绘制过程中，我们用matplotlib.pyplot模块下的figure（）函数来创建显示窗口，该函数的格式为：

matplotlib.pyplot.figure(num=None, figsize=None, dpi=None, facecolor=None, edgecolor=None)

所有参数都是可选的，都有默认值，因此调用该函数时可以不带任何参数，其中：

num: 整型或字符型都可以。如果设置为整型，则该整型数字表示窗口的序号。如果设置为字符型，则该字符串表示窗口的名称。用该参数来命名窗口，如果两个窗口序号或名相同，则后一个窗口会覆盖前一个窗口。

figsize: 设置窗口大小。是一个tuple型的整数，如figsize=（8，8）

dpi: 整形数字，表示窗口的分辨率。

facecolor: 窗口的背景颜色。
edgecolor: 窗口的边框颜色。

用figure()函数创建的窗口，只能显示一幅图片，如果想要显示多幅图片，则需要将这个窗口再划分为几个子图，在每个子图中显示不同的图片。我们可以使用subplot（）函数来划分子图，函数格式为：
matplotlib.pyplot.subplot(nrows, ncols, plot_number)
nrows: 子图的行数。
ncols: 子图的列数。
plot_number: 当前子图的编号。

import cv2
import matplotlib.pyplot as plt
from skimage import data
img=io.imread('mao.jpg')
#创建了一个新的matplotlib窗口，并将其命名为’astronaut’。窗口的大小被设置为8x8。
plt.figure(num='astronaut',figsize=(8,8))
#分割为三个独立的颜色
r, g, b = cv2.split(img)
#2x2的子图布局，选择第一个子图
plt.subplot(2,2,1)
plt.title('1')
plt.imshow(img)

plt.subplot(2,2,2)
plt.title('2')
plt.imshow(r)

plt.subplot(2,2,3)
plt.title('3')
plt.imshow(b)

plt.subplot(2,2,4)
plt.title('4')
plt.imshow(g)

22.对图像进行批量处理

这个函数是放在io模块内的，带两个参数，第一个参数load_pattern, 表示图片组的路径，可以是一个str字符串。第二个参数load_func是一个回调函数，我们对图片进行批量处理就可以通过这个回调函数实现。回调函数默认为imread(),即默认这个函数是批量读取图片。

1.

import skimage.io as io
from skimage import data_dir
#将data_dir与通配符*和.png结合起来
str = data_dir+'/*.png'
#使用io.ImageCollection类创建了一个集合，该集合包含所有匹配文件匹配模式的文件
coll = io.ImageCollection(str)
#打印了coll的长度，即其中包含的图像数量
print(len(coll))
#显示coll中的第7张图像
io.imshow(coll[6])
io.show()

2.

对批量图片转成灰度图像

from skimage import data_dir,io,color
def convert_gray(f):
    rgb=io.imread(f)
    return color.rgb2gray(rgb)
str = data_dir+'/*.png'
coll = io.ImageCollection(str,load_func=convert_gray)
io.imshow(coll[8])