nrows python_python skimage图像处理(一)

基于python脚本语言开发的数字图片处理包，比如PIL,Pillow, opencv, scikit-image等。

PIL和Pillow只提供最基础的数字图像处理，功能有限；opencv实际上是一个c++库，只是提供了python接口，更新速度非常慢。scikit-image是基于scipy的一款图像处理包，它将图片作为numpy数组进行处理，正好与matlab一样，因此，我们最终选择scikit-image进行数字图像处理。

Image读出来的是PIL的类型，而skimage.io读出来的数据是numpy格式的

import Image as img

import os

from matplotlib import pyplot as plot

from skimage import io,transform

#Image和skimage读图片

img_file1 = img.open('./CXR_png/MCUCXR_0042_0.png')

img_file2 = io.imread('./CXR_png/MCUCXR_0042_0.png')

输出可以看出Img读图片的大小是图片的(width, height)；而skimage的是(height,width, channel), [这也是为什么caffe在单独测试时要要在代码中设置：transformer.set_transpose('data',(2,0,1))，因为caffe可以处理的图片的数据格式是(channel,height,width)，所以要转换数据]

#读图片后数据的大小：

print "the picture's size: ", img_file1.size

print "the picture's shape: ", img_file2.shape

the picture's size: (4892, 4020)

the picture's shape: (4020, 4892)

#得到像素：

print(img_file1.getpixel((500,1000)), img_file2[500][1000])

print(img_file1.getpixel((500,1000)), img_file2[1000][500])

print(img_file1.getpixel((1000,500)), img_file2[500][1000])

(0, 139)

(0, 0)

(139, 139)

Img读出来的图片获得某点像素用getpixel((w,h))可以直接返回这个点三个通道的像素值

skimage读出来的图片可以直接img_file2[0][0]获得，但是一定记住它的格式，并不是你想的(channel,height,width)

图片信息

如果我们想知道一些skimage图片信息

from skimage import io, data

img = data.chelsea()

io.imshow(img)

print(type(img)) #显示类型

print(img.shape) #显示尺寸

print(img.shape[0]) #图片高度

print(img.shape[1]) #图片宽度

print(img.shape[2]) #图片通道数

print(img.size) #显示总像素个数

print(img.max()) #最大像素值

print(img.min()) #最小像素值

print(img.mean()) #像素平均值

print(img[0][0])#图像的像素值

PIL image 查看图片信息，可用如下的方法

print type(img)

print img.size #图片的尺寸

print img.mode #图片的模式

print img.format #图片的格式

print(img.getpixel((0,0)))#得到像素：

#img读出来的图片获得某点像素用getpixel((w,h))可以直接返回这个点三个通道的像素值

# 获取图像的灰度值范围

width = img.size[0]

height = img.size[1]

# 输出图片的像素值

count = 0

for i in range(0, width):

for j in range(0, height):

if img.getpixel((i, j))>=0 and img.getpixel((i, j))<=255:

count +=1

print count

print(height*width)

skimage提供了io模块，顾名思义，这个模块是用来图片输入输出操作的。为了方便练习，也提供一个data模块，里面嵌套了一些示例图片，我们可以直接使用。

skimage包的子模块

skimage包的全称是scikit-image SciKit (toolkit for SciPy) ，它对scipy.ndimage进行了扩展，提供了更多的图片处理功能。它是由python语言编写的，由scipy 社区开发和维护。skimage包由许多的子模块组成，各个子模块提供不同的功能。主要子模块列表如下：

子模块名称　 主要实现功能

io 读取、保存和显示图片或视频

data 提供一些测试图片和样本数据

color 颜色空间变换

filters 图像增强、边缘检测、排序滤波器、自动阈值等

draw 操作于numpy数组上的基本图形绘制，包括线条、矩形、圆和文本等

transform 几何变换或其它变换，如旋转、拉伸和拉东变换等

morphology 形态学操作，如开闭运算、骨架提取等

exposure 图片强度调整，如亮度调整、直方图均衡等

feature 特征检测与提取等

measure 图像属性的测量，如相似性或等高线等

segmentation 图像分割

restoration 图像恢复

util 通用函数

从外部读取图片并显示

读取单张彩色rgb图片，使用skimage.io.imread(fname)函数,带一个参数，表示需要读取的文件路径。显示图片使用skimage.io.imshow(arr)函数，带一个参数，表示需要显示的arr数组(读取的图片以numpy数组形式计算)。

from skimage import io

img=io.imread('d:/dog.jpg')

io.imshow(img)

读取单张灰度图片，使用skimage.io.imread(fname，as_grey=True)函数，第一个参数为图片路径，第二个参数为as_grey, bool型值，默认为False

from skimage import io

img=io.imread('d:/dog.jpg',as_grey=True)

io.imshow(img)

程序自带图片

skimage程序自带了一些示例图片，如果我们不想从外部读取图片，就可以直接使用这些示例图片：

astronaut 航员图片 coffee 一杯咖啡图片

lena lena美女图片 camera 拿相机的人图片

coins 硬币图片 moon 月亮图片

checkerboard 棋盘图片 horse 马图片

page 书页图片 chelsea 小猫图片

hubble_deep_field 星空图片 text 文字图片

clock 时钟图片 immunohistochemistry 结肠图片

显示这些图片可用如下代码，不带任何参数

from skimage import io, data

img=data.lena()

io.imshow(img)

图片名对应的就是函数名，如camera图片对应的函数名为camera(). 这些示例图片存放在skimage的安装目录下面，路径名称为data_dir,我们可以将这个路径打印出来看看

from skimage import data_dir

print(data_dir)

保存图片

使用io模块的imsave(fname,arr)函数来实现。第一个参数表示保存的路径和名称，第二个参数表示需要保存的数组变量。

from skimage import io,data

img=data.chelsea()

io.imshow(img)

io.imsave('d:/cat.jpg',img)

保存图片的同时也起到了转换格式的作用。如果读取时图片格式为jpg图片，保存为png格式，则将图片从jpg图片转换为png图片并保存。

图片信息

如果我们想知道一些图片信息

from skimage import io, data

img = data.chelsea()

io.imshow(img)

print(type(img)) #显示类型

print(img.shape) #显示尺寸

print(img.shape[0]) #图片高度

print(img.shape[1]) #图片宽度

print(img.shape[2]) #图片通道数

print(img.size) #显示总像素个数

print(img.max()) #最大像素值

print(img.min()) #最小像素值

print(img.mean()) #像素平均值

print(img[0][0])#图像的像素值

图像像素的访问与裁剪

图片读入程序中后，是以numpy数组存在的。因此对numpy数组的一切功能，对图片也适用。对数组元素的访问，实际上就是对图片像素点的访问。

彩色图片访问方式为：img[i,j,c]

i表示图片的行数，j表示图片的列数，c表示图片的通道数(RGB三通道分别对应0，1，2)。坐标是从左上角开始。

灰度图片访问方式为：gray[i,j]

例1：输出小猫图片的G通道中的第20行30列的像素值

from skimage import io,data

img=data.chelsea()

pixel=img[20,30,1]

print(pixel)

例2：显示红色单通道图片

from skimage import io,data

img=data.chelsea()

R=img[:,:,0]

io.imshow(R)

除了对像素进行读取，也可以修改像素值。

例3：对小猫图片随机添加椒盐噪声

from skimage import io,data

import numpy as np

img=data.chelsea()

#随机生成5000个椒盐

rows,cols,dims=img.shape

for i in range(5000):

x=np.random.randint(0,rows)

y=np.random.randint(0,cols)

img[x,y,:]=255

io.imshow(img)

这里用到了numpy包里的random来生成随机数，randint(0,cols)表示随机生成一个整数，范围在0到cols之间。

用img[x,y,:]=255这句来对像素值进行修改，将原来的三通道像素值，变为255

通过对数组的裁剪，就可以实现对图片的裁剪。

例4：对小猫图片进行裁剪

from skimage import io,data

img=data.chelsea()

roi=img[80:180,100:200,:]

io.imshow(roi)

对多个像素点进行操作，使用数组切片方式访问。切片方式返回的是以指定间隔下标访问 该数组的像素值。下面是有关灰度图像的一些例子：

img[i,:] = im[j,:] # 将第 j 行的数值赋值给第 i 行

img[:,i] = 100 # 将第 i 列的所有数值设为 100

img[:100,:50].sum() # 计算前 100 行、前 50 列所有数值的和

img[50:100,50:100] # 50~100 行，50~100 列(不包括第 100 行和第 100 列)

img[i].mean() # 第 i 行所有数值的平均值

img[:,-1] # 最后一列

img[-2,:] (or im[-2]) # 倒数第二行

最后我们再看两个对像素值进行访问和改变的例子：

例5：将lena图片进行二值化，像素值大于128的变为1，否则变为0

from skimage import io,data,color

img=data.lena()

img_gray=color.rgb2gray(img)

rows,cols=img_gray.shape

for i in range(rows):

for j in range(cols):

if (img_gray[i,j]<=0.5):

img_gray[i,j]=0

else:

img_gray[i,j]=1

io.imshow(img_gray)

使用了color模块的rgb2gray()函数，将彩色三通道图片转换成灰度图。转换结果为float64类型的数组，范围为[0,1]之间。

将彩色三通道图片转换成灰度图,最后变成unit8, float转换为unit8是有信息损失的。

img_path = 'data/dpclassifier/newtrain/test/1_0.png'

import Image as img

import os

from matplotlib import pyplot as plot

from skimage import io,transform, img_as_ubyte

img_file1 = img.open(img_path)

img_file1.show()

img_file2 = io.imread(img_path)

io.imshow(img_file2)

print(type(img_file1),img_file1.mode, type(img_file2),img_file2.shape, img_file2.dtype,img_file2.max(),img_file2.min(),img_file2.mean())

img_file22=skimage.color.rgb2gray(img_file2)

print(type(img_file22),img_file22.shape,img_file22.dtype,img_file22.max(),img_file22.min(),img_file22.mean() )

dst=img_as_ubyte(img_file22)

print(type(dst),dst.shape,dst.dtype, dst.max(), dst.min(), dst.mean())

结果

(, 'RGB', , (420, 512, 3), dtype('uint8'), 255, 0, 130.9983863467262)

(, (420, 512), dtype('float64'), 1.0, 0.0, 0.5137191621440242)

(, (420, 512), dtype('uint8'), 255, 0, 130.9983863467262)

例6：

from skimage import io,data

img=data.chelsea()

reddish = img[:, :, 0] >170

img[reddish] = [0, 255, 0]

io.imshow(img)

这个例子先对R通道的所有像素值进行判断，如果大于170，则将这个地方的像素值变为[0,255,0], 即G通道值为255，R和B通道值为0。

图像数据类型及颜色空间转换

在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

一张图片的像素值范围是[0,255], 因此默认类型是unit8, 可用如下代码查看数据类型

from skimage import io,data

img=data.chelsea()

print(img.dtype.name)

在上面的表中，特别注意的是float类型，它的范围是[-1,1]或[0,1]之间。一张彩色图片转换为灰度图后，它的类型就由unit8变成了float

1、unit8转float

from skimage import data,img_as_float

img=data.chelsea()

print(img.dtype.name)

dst=img_as_float(img)

print(dst.dtype.name)

2、float转uint8

from skimage import img_as_ubyte

import numpy as np

img = np.array([0, 0.5, 1], dtype=float)

print(img.dtype.name)

dst=img_as_ubyte(img)

print(dst.dtype.name)

float转为unit8，有可能会造成数据的损失，因此会有警告提醒。*

除了这两种最常用的转换以外，其实有一些其它的类型转换，如下表：

Function name Description

img_as_float Convert to 64-bit floating point.

img_as_ubyte Convert to 8-bit uint.

img_as_uint Convert to 16-bit uint.

img_as_int Convert to 16-bit int.

如前所述，除了直接转换可以改变数据类型外，还可以通过图像的颜色空间转换来改变数据类型。

常用的颜色空间有灰度空间、rgb空间、hsv空间和cmyk空间。颜色空间转换以后，图片类型都变成了float型。

所有的颜色空间转换函数，都放在skimage的color模块内。

例：rgb转灰度图

from skimage import io,data,color

img=data.lena()

gray=color.rgb2gray(img)

io.imshow(gray)

其它的转换，用法都是一样的，列举常用的如下：

skimage.color.rgb2grey(rgb)

skimage.color.rgb2hsv(rgb)

skimage.color.rgb2lab(rgb)

skimage.color.gray2rgb(image)

skimage.color.hsv2rgb(hsv)

skimage.color.lab2rgb(lab)

实际上，上面的所有转换函数，都可以用一个函数来代替

skimage.color.convert_colorspace(arr, fromspace, tospace)

表示将arr从fromspace颜色空间转换到tospace颜色空间。

例：rgb转hsv

from skimage import io,data,color

img=data.lena()

hsv=color.convert_colorspace(img,'RGB','HSV')

io.imshow(hsv)

在color模块的颜色空间转换函数中，还有一个比较有用的函数是

skimage.color.label2rgb(arr), 可以根据标签值对图片进行着色。以后的图片分类后着色就可以用这个函数。

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

from skimage import io,data,color

import numpy as np

img=data.lena()

gray=color.rgb2gray(img)

rows,cols=gray.shape

labels=np.zeros([rows,cols])

for i in range(rows):

for j in range(cols):

if(gray[i,j]<0.4):

labels[i,j]=0

elif(gray[i,j]<0.75):

labels[i,j]=1

else:

labels[i,j]=2

dst=color.label2rgb(labels)

io.imshow(dst)

图像的绘制

实际上前面我们就已经用到了图像的绘制，如：

io.imshow(img)

这一行代码的实质是利用matplotlib包对图片进行绘制，绘制成功后，返回一个matplotlib类型的数据。因此，我们也可以这样写：

import matplotlib.pyplot as plt

plt.imshow(img)

imshow()函数格式为：

matplotlib.pyplot.imshow(X, cmap=None)

X: 要绘制的图像或数组。

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

其它可选的颜色图谱如下列表：

颜色图谱 描述

autumn 红-橙-黄

bone 黑-白，x线

cool 青-洋红

copper 黑-铜

flag 红-白-蓝-黑

gray 黑-白

hot 黑-红-黄-白

hsv hsv颜色空间， 红-黄-绿-青-蓝-洋红-红

inferno 黑-红-黄

jet 蓝-青-黄-红

magma 黑-红-白

pink 黑-粉-白

plasma 绿-红-黄

prism 红-黄-绿-蓝-紫-...-绿模式

spring 洋红-黄

summer 绿-黄

viridis 蓝-绿-黄

winter 蓝-绿

用的比较多的有gray,jet等，如：

plt.imshow(image,plt.cm.gray)

plt.imshow(img,cmap=plt.cm.jet)

在窗口上绘制完图片后，返回一个AxesImage对象。要在窗口上显示这个对象，我们可以调用show()函数来进行显示，但进行练习的时候(ipython环境中)，一般我们可以省略show()函数，也能自动显示出来。

from skimage import io,data

img=data.astronaut()

dst=io.imshow(img)

print(type(dst))

io.show()

可以看到，类型是'matplotlib.image.AxesImage'。显示一张图片，我们通常更愿意这样写：

import matplotlib.pyplot as plt

from skimage import io,data

img=data.astronaut()

plt.imshow(img)

plt.show()

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

import matplotlib.pyplot as plt

也就是说，我们绘图实际上用的是matplotlib包的pyplot模块。

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

分开并同时显示宇航员图片的三个通道

from skimage import data

import matplotlib.pyplot as plt

img=data.astronaut()

plt.figure(num='astronaut',figsize=(8,8)) #创建一个名为astronaut的窗口,并设置大小

plt.subplot(2,2,1) #将窗口分为两行两列四个子图，则可显示四幅图片

plt.title('origin image') #第一幅图片标题

plt.imshow(img) #绘制第一幅图片

plt.subplot(2,2,2) #第二个子图

plt.title('R channel') #第二幅图片标题

plt.imshow(img[:,:,0],plt.cm.gray) #绘制第二幅图片,且为灰度图

plt.axis('off') #不显示坐标尺寸

plt.subplot(2,2,3) #第三个子图

plt.title('G channel') #第三幅图片标题

plt.imshow(img[:,:,1],plt.cm.gray) #绘制第三幅图片,且为灰度图

plt.axis('off') #不显示坐标尺寸

plt.subplot(2,2,4) #第四个子图

plt.title('B channel') #第四幅图片标题

plt.imshow(img[:,:,2],plt.cm.gray) #绘制第四幅图片,且为灰度图

plt.axis('off') #不显示坐标尺寸

plt.show() #显示窗口

在图片绘制过程中，我们用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: 当前子图的编号。

如：

plt.subplot(2,2,1)

则表示将figure窗口划分成了2行2列共4个子图，当前为第1个子图。我们有时也可以用这种写法：

plt.subplot(221)

两种写法效果是一样的。每个子图的标题可用title()函数来设置，是否使用坐标尺可用axis()函数来设置，如：

plt.subplot(221)

plt.title("first subwindow")

plt.axis('off')

用subplots来创建显示窗口与划分子图

除了上面那种方法创建显示窗口和划分子图，还有另外一种编写方法也可以，如下例:

import matplotlib.pyplot as plt

from skimage import data,color

img = data.immunohistochemistry()

hsv = color.rgb2hsv(img)

fig, axes = plt.subplots(2, 2, figsize=(7, 6))

ax0, ax1, ax2, ax3 = axes.ravel()

ax0.imshow(img)

ax0.set_title("Original image")

ax1.imshow(hsv[:, :, 0], cmap=plt.cm.gray)

ax1.set_title("H")

ax2.imshow(hsv[:, :, 1], cmap=plt.cm.gray)

ax2.set_title("S")

ax3.imshow(hsv[:, :, 2], cmap=plt.cm.gray)

ax3.set_title("V")

for ax in axes.ravel():

ax.axis('off')

fig.tight_layout() #自动调整subplot间的参数

直接用subplots()函数来创建并划分窗口。注意，比前面的subplot()函数多了一个s，该函数格式为：

matplotlib.pyplot.subplots(nrows=1, ncols=1)

nrows: 所有子图行数，默认为1。

ncols: 所有子图列数，默认为1。

返回一个窗口figure, 和一个tuple型的ax对象，该对象包含所有的子图,可结合ravel()函数列出所有子图，如：

fig, axes = plt.subplots(2, 2, figsize=(7, 6))

ax0, ax1, ax2, ax3 = axes.ravel()

创建了2行2列4个子图，分别取名为ax0,ax1,ax2和ax3, 每个子图的标题用set_title()函数来设置，如：

ax0.imshow(img)

ax0.set_title("Original image")

如果有多个子图，我们还可以使用tight_layout()函数来调整显示的布局，该函数格式为：

matplotlib.pyplot.tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None)

所有的参数都是可选的，调用该函数时可省略所有的参数。

pad: 主窗口边缘和子图边缘间的间距，默认为1.08

h_pad, w_pad: 子图边缘之间的间距，默认为 pad_inches

rect: 一个矩形区域，如果设置这个值，则将所有的子图调整到这个矩形区域内。

一般调用为：

plt.tight_layout() #自动调整subplot间的参数

其它方法绘图并显示

除了使用matplotlib库来绘制图片，skimage还有另一个子模块viewer，也提供一个函数来显示图片。不同的是，它利用Qt工具来创建一块画布，从而在画布上绘制图像。

例：

from skimage import data

from skimage.viewer import ImageViewer

img = data.coins()

viewer = ImageViewer(img)

viewer.show()

最后总结一下，绘制和显示图片常用到的函数有：

函数名 功能 调用格式

figure 创建一个显示窗口 plt.figure(num=1,figsize=(8,8)

imshow 绘制图片 plt.imshow(image)

show 显示窗口 plt.show()

subplot 划分子图 plt.subplot(2,2,1)

title 设置子图标题(与subplot结合使用) plt.title('origin image')

axis 是否显示坐标尺 plt.axis('off')

subplots 创建带有多个子图的窗口 fig,axes=plt.subplots(2,2,figsize=(8,8))

ravel 为每个子图设置变量 ax0,ax1,ax2,ax3=axes.ravel()

set_title 设置子图标题(与axes结合使用) ax0.set_title('first window')

tight_layout 自动调整子图显示布局 plt.tight_layout()

图像的批量处理

有些时候，我们不仅要对一张图片进行处理，可能还会对一批图片处理。这时候，我们可以通过循环来执行处理，也可以调用程序自带的图片集合来处理。

图片集合函数为：

skimage.io.ImageCollection(load_pattern,load_func=None)

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

先看一个例子：

import skimage.io as io

from skimage import data_dir

str=data_dir + '/*.png'

coll = io.ImageCollection(str)

print(len(coll))

显示结果为25, 说明系统自带了25张png的示例图片，这些图片都读取了出来，放在图片集合coll里。如果我们想显示其中一张图片，则可以在后加上一行代码：

io.imshow(coll[10])

显示为：

如果一个文件夹里，我们既存放了一些jpg格式的图片，又存放了一些png格式的图片，现在想把它们全部读取出来，该怎么做呢?

import skimage.io as io

from skimage import data_dir

str='d:/pic/*.jpg:d:/pic/*.png'

coll = io.ImageCollection(str)

print(len(coll))

注意这个地方'd:/pic/.jpg:d:/pic/.png' ，是两个字符串合在一起的，第一个是'd:/pic/.jpg', 第二个是'd:/pic/.png' ，合在一起后，中间用冒号来隔开，这样就可以把d:/pic/文件夹下的jpg和png格式的图片都读取出来。如果还想读取存放在其它地方的图片，也可以一并加进去，只是中间同样用冒号来隔开。

io.ImageCollection()这个函数省略第二个参数，就是批量读取。如果我们不是想批量读取，而是其它批量操作，如批量转换为灰度图，那又该怎么做呢？

那就需要先定义一个函数，然后将这个函数作为第二个参数，如：

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[10])

这种批量操作对视频处理是极其有用的，因为视频就是一系列的图片组合

from skimage import data_dir,io,color

class AVILoader:

video_file = 'myvideo.avi'

def __call__(self, frame):

return video_read(self.video_file, frame)

avi_load = AVILoader()

frames = range(0, 1000, 10) # 0, 10, 20, ...ic =io.ImageCollection(frames, load_func=avi_load)

这段代码的意思，就是将myvideo.avi这个视频中每隔10帧的图片读取出来，放在图片集合中。

得到图片集合以后，我们还可以将这些图片连接起来，构成一个维度更高的数组，连接图片的函数为：

skimage.io.concatenate_images(ic)

带一个参数，就是以上的图片集合，如：

from skimage import data_dir,io,color

coll = io.ImageCollection('d:/pic/*.jpg')

mat=io.concatenate_images(coll)

使用concatenate_images(ic)函数的前提是读取的这些图片尺寸必须一致，否则会出错。我们看看图片连接前后的维度变化：

from skimage import data_dir,io,color

coll = io.ImageCollection('d:/pic/*.jpg')

print(len(coll)) #连接的图片数量

print(coll[0].shape) #连接前的图片尺寸，所有的都一样

mat=io.concatenate_images(coll)

print(mat.shape) #连接后的数组尺寸

显示结果：

2

(870, 580, 3)

(2, 870, 580, 3)

可以看到，将2个3维数组，连接成了一个4维数组

如果我们对图片进行批量操作后，想把操作后的结果保存起来，也是可以办到的。

例：把系统自带的所有png示例图片，全部转换成256256的jpg格式灰度图，保存在d:/data/文件夹下*

改变图片的大小，我们可以使用tranform模块的resize()函数，后续会讲到这个模块。

from skimage import data_dir,io,transform,color

import numpy as np

def convert_gray(f):

rgb=io.imread(f) #依次读取rgb图片

gray=color.rgb2gray(rgb) #将rgb图片转换成灰度图

dst=transform.resize(gray,(256,256)) #将灰度图片大小转换为256*256

return dst str=data_dir+'/*.png'

coll = io.ImageCollection(str,load_func=convert_gray)

for i in range(len(coll)):

io.imsave('d:/data/'+np.str(i)+'.jpg',coll[i]) #循环保存图片

结果：

图像的形变与缩放

图像的形变与缩放，使用的是skimage的transform模块，函数比较多，功能齐全。

1、改变图片尺寸resize

函数格式为：

skimage.transform.resize(image, output_shape)

image: 需要改变尺寸的图片

output_shape: 新的图片尺寸

from skimage import transform,data

import matplotlib.pyplot as plt

img = data.camera()

dst=transform.resize(img, (80, 60))

plt.figure('resize')

plt.subplot(121)

plt.title('before resize')

plt.imshow(img,plt.cm.gray)

plt.subplot(122)

plt.title('before resize')

plt.imshow(dst,plt.cm.gray)

plt.show()

将camera图片由原来的512x512大小，变成了80x60大小。从下图中的坐标尺，我们能够看出来：

2、按比例缩放rescale

函数格式为：

skimage.transform.rescale(image, scale[, ...])

scale参数可以是单个float数，表示缩放的倍数，也可以是一个float型的tuple，如[0.2,0.5],表示将行列数分开进行缩放

from skimage import transform,data

img = data.camera()

print(img.shape) #图片原始大小

print(transform.rescale(img, 0.1).shape) #缩小为原来图片大小的0.1

print(transform.rescale(img, [0.5,0.25]).shape) #缩小为原来图片行数一半，列数四分之一

print(transform.rescale(img, 2).shape) #放大为原来图片大小的2倍

结果为：

(512, 512)

(51, 51)

(256, 128)

(1024, 1024)

3、旋转 rotate

skimage.transform.rotate(image, angle[, ...],resize=False)

angle参数是个float类型数，表示旋转的度数

resize用于控制在旋转时，是否改变大小 ，默认为False

from skimage import transform,data

import matplotlib.pyplot as plt

img = data.camera()

print(img.shape) #图片原始大小

img1=transform.rotate(img, 60) #旋转90度，不改变大小

print(img1.shape)

img2=transform.rotate(img, 30,resize=True) #旋转30度，同时改变大小

print(img2.shape) plt.figure('resize')

plt.subplot(121)plt.title('rotate 60')

plt.imshow(img1,plt.cm.gray)

plt.subplot(122)

plt.title('rotate 30')

plt.imshow(img2,plt.cm.gray)

plt.show()

显示结果:

4、图像金字塔

以多分辨率来解释图像的一种有效但概念简单的结构就是图像金字塔。图像金字塔最初用于机器视觉和图像压缩，一幅图像的金字塔是一系列以金字塔形状排列的分辨率逐步降低的图像集合。金字塔的底部是待处理图像的高分辨率表示，而顶部是低分辨率的近似。当向金字塔的上层移动时，尺寸和分辨率就降低。

在此，我们举一个高斯金字塔的应用实例，函数原型为：

skimage.transform.pyramid_gaussian(image, downscale=2)

downscale控制着金字塔的缩放比例

import numpy as np

import matplotlib.pyplot as plt

from skimage import data,transform

image = data.astronaut() #载入宇航员图片

rows, cols, dim = image.shape #获取图片的行数，列数和通道数

pyramid = tuple(transform.pyramid_gaussian(image, downscale=2)) #产生高斯金字塔图像#共生成了log(512)=9幅金字塔图像，加上原始图像共10幅，pyramid[0]-pyramid[1]

composite_image = np.ones((rows, cols + cols / 2, 3), dtype=np.double) #生成背景composite_image[:rows, :cols, :] = pyramid[0] #融合原始图像

i_row = 0

for p in pyramid[1:]:

n_rows, n_cols = p.shape[:2]

composite_image[i_row:i_row + n_rows, cols:cols + n_cols] = p #循环融合9幅金字塔图像

i_row += n_rows

plt.imshow(composite_image)

plt.show()

上右图，就是10张金字塔图像，下标为0的表示原始图像，后面每层的图像行和列变为上一层的一半，直至变为1

除了高斯金字塔外，还有其它的金字塔，如：

skimage.transform.pyramid_laplacian(image, downscale=2)

对比度与亮度调整

图像亮度与对比度的调整，是放在skimage包的exposure模块里面

1、gamma调整

原理：I=Ig

对原图像的像素，进行幂运算，得到新的像素值。公式中的g就是gamma值。

如果gamma>1, 新图像比原图像暗

如果gamma<1,新图像比原图像亮

函数格式为：

skimage.exposure.adjust_gamma(image, gamma=1)

gamma参数默认为1，原像不发生变化 。

from skimage import data, exposure, img_as_float

import matplotlib.pyplot as plt

image = img_as_float(data.moon())

gam1= exposure.adjust_gamma(image, 2) #调暗

gam2= exposure.adjust_gamma(image, 0.5) #调亮plt.figure('adjust_gamma',figsize=(8,8))

plt.subplot(131)plt.title('origin image')

plt.imshow(image,plt.cm.gray)plt.axis('off')

plt.subplot(132)

plt.title('gamma=2')

plt.imshow(gam1,plt.cm.gray)

plt.axis('off')

plt.subplot(133)

plt.title('gamma=0.5')

plt.imshow(gam2,plt.cm.gray)

plt.axis('off')

plt.show()

2、log对数调整

这个刚好和gamma相反

原理：I=log(I)

from skimage import data, exposure, img_as_float

import matplotlib.pyplot as plt

image = img_as_float(data.moon())

gam1= exposure.adjust_log(image) #对数调整

plt.figure('adjust_gamma',figsize=(8,8))

plt.subplot(121)plt.title('origin image')

plt.imshow(image,plt.cm.gray)

plt.axis('off')

plt.subplot(122)

plt.title('log')

plt.imshow(gam1,plt.cm.gray)

plt.axis('off')

plt.show()

3、判断图像对比度是否偏低

函数：is_low_contrast(img)

返回一个bool型值

from skimage import data, exposure

image =data.moon()

result=exposure.is_low_contrast(image)

print(result)

输出为False

4、调整强度

函数：

skimage.exposure.rescale_intensity(image, in_range='image', out_range='dtype')

in_range 表示输入图片的强度范围，默认为'image', 表示用图像的最大/最小像素值作为范围

out_range 表示输出图片的强度范围，默认为'dype', 表示用图像的类型的最大/最小值作为范围

默认情况下，输入图片的[min,max]范围被拉伸到[dtype.min, dtype.max]，如果dtype=uint8, 那么dtype.min=0, dtype.max=255

import numpy as np

from skimage import exposure

image = np.array([51, 102, 153], dtype=np.uint8)

mat=exposure.rescale_intensity(image)

print(mat)

输出为[ 0 127 255]

即像素最小值由51变为0，最大值由153变为255，整体进行了拉伸，但是数据类型没有变，还是uint8

前面我们讲过，可以通过img_as_float()函数将unit8类型转换为float型，实际上还有更简单的方法，就是乘以1.0

import numpy as np

image = np.array([51, 102, 153], dtype=np.uint8)

print(image*1.0)

即由[51,102,153]变成了[ 51. 102. 153.]

而float类型的范围是[0,1]，因此对float进行rescale_intensity 调整后，范围变为[0,1],而不是[0,255]

import numpy as np

from skimage import exposure

image = np.array([51, 102, 153], dtype=np.uint8)

tmp=image*1.0

mat=exposure.rescale_intensity(tmp)

print(mat)

结果为[ 0. 0.5 1. ]

如果原始像素值不想被拉伸，只是等比例缩小，就使用in_range参数，如：

import numpy as np

from skimage import exposure

image = np.array([51, 102, 153], dtype=np.uint8)

tmp=image*1.0

mat=exposure.rescale_intensity(tmp,in_range=(0,255))

print(mat)

输出为：[ 0.2 0.4 0.6]，即原像素值除以255

如果参数in_range的[main,max]范围要比原始像素值的范围[min,max] 大或者小，那就进行裁剪，如：

mat=exposure.rescale_intensity(tmp,in_range=(0,102))

print(mat)

输出[ 0.5 1. 1. ]，即原像素值除以102，超出1的变为1

如果一个数组里面有负数，现在想调整到正数，就使用out_range参数。如：

import numpy as np

from skimage import exposure

image = np.array([-10, 0, 10], dtype=np.int8)

mat=exposure.rescale_intensity(image, out_range=(0, 127))

print(mat)

输出[ 0 63 127]

直方图与均衡化

在图像处理中，直方图是非常重要，也是非常有用的一个处理要素。

在skimage库中对直方图的处理，是放在exposure这个模块中。

1、计算直方图

函数：

skimage.exposure.histogram(image, nbins=256)

在numpy包中，也提供了一个计算直方图的函数histogram(),两者大同小义。

返回一个tuple(hist, bins_center), 前一个数组是直方图的统计量，后一个数组是每个bin的中间值

import numpy as np

from skimage import exposure,data

image =data.camera()*1.0

hist1=np.histogram(image, bins=2) #用numpy包计算直方图hist2=exposure.histogram(image, nbins=2) #用skimage计算直方图

print(hist1)

print(hist2)

输出：

(array([107432, 154712], dtype=int64), array([ 0. , 127.5, 255. ]))

(array([107432, 154712], dtype=int64), array([ 63.75, 191.25]))

分成两个bin，每个bin的统计量是一样的，但numpy返回的是每个bin的两端的范围值，而skimage返回的是每个bin的中间值

2、绘制直方图

绘图都可以调用matplotlib.pyplot库来进行，其中的hist函数可以直接绘制直方图。

调用方式：

n, bins, patches = plt.hist(arr, bins=10, normed=0, facecolor='black', edgecolor='black',alpha=1，histtype='bar')

hist的参数非常多，但常用的就这六个，只有第一个是必须的，后面四个可选

arr: 需要计算直方图的一维数组

bins: 直方图的柱数，可选项，默认为10

normed: 是否将得到的直方图向量归一化。默认为0

facecolor: 直方图颜色

edgecolor: 直方图边框颜色

alpha: 透明度

histtype: 直方图类型，‘bar’, ‘barstacked’, ‘step’, ‘stepfilled’

返回值 ：

n: 直方图向量，是否归一化由参数normed设定

bins: 返回各个bin的区间范围

patches: 返回每个bin里面包含的数据，是一个list

from skimage import data

import matplotlib.pyplot as plt

img=data.camera()

plt.figure("hist")

arr=img.flatten()

n, bins, patches = plt.hist(arr, bins=256, normed=1,edgecolor='None',facecolor='red')

plt.show()

其中的flatten()函数是numpy包里面的，用于将二维数组序列化成一维数组。

是按行序列，如

mat=[[1 2 3

4 5 6]]

经过 mat.flatten()后，就变成了

mat=[1 2 3 4 5 6]

3、彩色图片三通道直方图

一般来说直方图都是征对灰度图的，如果要画rgb图像的三通道直方图，实际上就是三个直方图的叠加。

from skimage import data

import matplotlib.pyplot as plt

img=data.lena()

ar=img[:,:,0].flatten()

plt.hist(ar, bins=256, normed=1,facecolor='r',edgecolor='r',hold=1)

ag=img[:,:,1].flatten()

plt.hist(ag, bins=256, normed=1, facecolor='g',edgecolor='g',hold=1)

ab=img[:,:,2].flatten()

plt.hist(ab, bins=256, normed=1, facecolor='b',edgecolor='b')

plt.show()

其中，加一个参数hold=1,表示可以叠加

4、直方图均衡化

如果一副图像的像素占有很多的灰度级而且分布均匀，那么这样的图像往往有高对比度和多变的灰度色调。直方图均衡化就是一种能仅靠输入图像直方图信息自动达到这种效果的变换函数。它的基本思想是对图像中像素个数多的灰度级进行展宽，而对图像中像素个数少的灰度进行压缩，从而扩展取值的动态范围，提高了对比度和灰度色调的变化，使图像更加清晰。

from skimage import data,exposure

import matplotlib.pyplot as plt

img=data.moon()

plt.figure("hist",figsize=(8,8))

arr=img.flatten()

plt.subplot(221)

plt.imshow(img,plt.cm.gray) #原始图像

plt.subplot(222)

plt.hist(arr, bins=256, normed=1,edgecolor='None',facecolor='red') #原始图像直方图

img1=exposure.equalize_hist(img)

arr1=img1.flatten()

plt.subplot(223)

plt.imshow(img1,plt.cm.gray) #均衡化图像

plt.subplot(224)

plt.hist(arr1, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

CLAHE

skimage.exposure.``equalize_adapthist(image, kernel_size=None, clip_limit=0.01, nbins=256)

Contrast Limited Adaptive Histogram Equalization (CLAHE).

An algorithm for local contrast enhancement, that uses histograms computed over different tile regions of the image. Local details can therefore be enhanced even in regions that are darker or lighter than most of the image.

image : (M, N[, C]) ndarray

Input image.

kernel_size: integer or list-like, optional

Defines the shape of contextual regions used in the algorithm. If iterable is passed, it must have the same number of elements as image.ndim (without color channel). If integer, it is broadcasted to each image dimension. By default, kernel_size is 1/8 of image height by 1/8 of its width.

clip_limit : float, optional

Clipping limit, normalized between 0 and 1 (higher values give more contrast).

nbins : int, optional

Number of gray bins for histogram (“data range”).

| Returns: |

out : (M, N[, C]) ndarray

Equalized image.

from skimage import data,exposure

import matplotlib.pyplot as plt

#%matplotlib notebook

clip_limitnumber=0.01

img=data.moon()

print(img.shape)

plt.figure("hist",figsize=(8,8))

arr=img.flatten()

plt.subplot(5,2,1)

plt.title('original')

plt.imshow(img,plt.cm.gray) #原始图像

plt.subplot(5,2,2)

plt.hist(arr, bins=256, normed=1,edgecolor='None',facecolor='red') #原始图像直方图

# #img1=exposure.equalize_hist(img)

# img1=exposure.equalize_hist(img)

# arr1=img1.flatten()

# plt.subplot(6,2,3)

# plt.title('equalize_hist')

# plt.imshow(img1,plt.cm.gray) #均衡化图像

# plt.subplot(6,2,4)

# plt.hist(arr1, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

# plt.show()

img2=exposure.equalize_adapthist(img, kernel_size=256, clip_limit=clip_limitnumber, nbins=256)

arr2=img2.flatten()

plt.subplot(5,2,3)

plt.title('equalize_adapthist-256-'+ str(clip_limitnumber))

plt.imshow(img2,plt.cm.gray) #均衡化图像

plt.subplot(5,2,4)

plt.hist(arr2, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img3=exposure.equalize_adapthist(img, kernel_size=128, clip_limit=clip_limitnumber, nbins=256)

arr3=img3.flatten()

plt.subplot(5,2,5)

plt.title('equalize_adapthist-128-'+ str(clip_limitnumber))

plt.imshow(img3,plt.cm.gray) #均衡化图像

plt.subplot(5,2,6)

plt.hist(arr3, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img4=exposure.equalize_adapthist(img, kernel_size=64, clip_limit=clip_limitnumber, nbins=256)

arr4=img4.flatten()

plt.subplot(5,2,7)

plt.title('equalize_adapthist-64-'+ str(clip_limitnumber))

plt.imshow(img4,plt.cm.gray) #均衡化图像

plt.subplot(5,2,8)

plt.hist(arr4, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img5=exposure.equalize_adapthist(img, kernel_size=32, clip_limit=clip_limitnumber, nbins=256)

arr5=img5.flatten()

plt.subplot(5,2,9)

plt.title('equalize_adapthist-32-'+ str(clip_limitnumber))

plt.imshow(img5,plt.cm.gray) #均衡化图像

plt.subplot(5,2,10)

plt.hist(arr5, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

1.png

from skimage import data,exposure

import matplotlib.pyplot as plt

#%matplotlib notebook

kernel_sizenuber=64

img=data.moon()

print(img.shape)

plt.figure("hist",figsize=(8,8))

arr=img.flatten()

plt.subplot(5,2,1)

plt.title('original')

plt.imshow(img,plt.cm.gray) #原始图像

plt.subplot(5,2,2)

plt.hist(arr, bins=256, normed=1,edgecolor='None',facecolor='red') #原始图像直方图

# #img1=exposure.equalize_hist(img)

# img1=exposure.equalize_hist(img)

# arr1=img1.flatten()

# plt.subplot(6,2,3)

# plt.title('equalize_hist')

# plt.imshow(img1,plt.cm.gray) #均衡化图像

# plt.subplot(6,2,4)

# plt.hist(arr1, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

# plt.show()

img2=exposure.equalize_adapthist(img, kernel_size=kernel_sizenuber, clip_limit=0.001, nbins=256)

arr2=img2.flatten()

plt.subplot(5,2,3)

plt.title('equalize_adapthist-'+ str(kernel_sizenuber)+'-0.001')

plt.imshow(img2,plt.cm.gray) #均衡化图像

plt.subplot(5,2,4)

plt.hist(arr2, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img3=exposure.equalize_adapthist(img, kernel_size=kernel_sizenuber, clip_limit=0.005, nbins=256)

arr3=img3.flatten()

plt.subplot(5,2,5)

plt.title('equalize_adapthist-'+ str(kernel_sizenuber)+'-0.005')

plt.imshow(img3,plt.cm.gray) #均衡化图像

plt.subplot(5,2,6)

plt.hist(arr3, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img4=exposure.equalize_adapthist(img, kernel_size=kernel_sizenuber, clip_limit=0.01, nbins=256)

arr4=img4.flatten()

plt.subplot(5,2,7)

plt.title('equalize_adapthist-'+ str(kernel_sizenuber)+'-0.01')

plt.imshow(img4,plt.cm.gray) #均衡化图像

plt.subplot(5,2,8)

plt.hist(arr4, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

img5=exposure.equalize_adapthist(img, kernel_size=kernel_sizenuber, clip_limit=0.05, nbins=256)

arr5=img5.flatten()

plt.subplot(5,2,9)

plt.title('equalize_adapthist-'+ str(kernel_sizenuber)+'-0.05')

plt.imshow(img5,plt.cm.gray) #均衡化图像

plt.subplot(5,2,10)

plt.hist(arr5, bins=256, normed=1,edgecolor='None',facecolor='red') #均衡化直方图

plt.show()

2.png