数字图像处理基础内容

一.图像基础内容

1.什么是图像？
图像定义为二维函数f(x,y)，x,y定义为空间坐标，f(x,y)是点（x,y）的幅值。包括灰度图和彩色图。

• 灰度图：灰度图像是一个二维灰度（或亮度）函数f(x,y)
• 彩色图：彩色图像由三个（RGB，HSV）二维灰度（或亮度）函数f(x,y)组成。

2.什么是像素？
数字图像由二维的元素组成，每一个元素具有一个特定的位置（x,y）和幅值f(x,y），这些元素称为像素。

3.什么是数字图像？
像素组成的二维排列，可以用矩阵表示。

• 单色（灰度）图像，每个像素的亮度用一个数值表示，8bit=1Byte表示256位，0-255之间，0表示黑色，255表示白，其他值表示处于黑白之间的灰度
• 彩色图像可以用红，绿，蓝三元组的二维矩阵表示，通常三元组的每个数值也是在0-255之间，0表示相应的基色在该像素中没有，而255则代表相应的基色在像素中取得最大值。

二.图像的读取，显示，保存

skimage模块提供了io文件读取功能，可以对图片进行操作。

from skimage import io

一、从外部读取图片并显示

问题解决办法：
当遇到读取图片无法打开时可能时图片的格式不对，.jpg格式可以，其他格式需要安装插件，最好的办法不要下载网上的图片，找之前的项目图片格式。报错信息如下：
UnidentifiedImageError: cannot identify image file ‘./fj.jpg’

1. 使用skimage里面的io属性进行读取图片内容,imread需要传入图片的路径，注意图片的格式

from skimage import io
img = io.imread('data.jpg')
io.imshow(img)
print(img.shape)

如果想要展示成灰色图片，可以使用as_gray属性

img = io.imread('data.jpg',as_gray=True)
io.imshow(img)
print(img.shape)

彩色和灰色的区别就是图像的维度到底是几维的，二维位灰度图，三维为彩色图

二、程序自带图片

skimage自带了一些图片,这些图片内容在data包里面

from skimage import io,data
img = data.coffee()
io.imshow(img)

其实这些图片在skimage的安装目录的data目录下面，可以使用代码进行查看

from skimage import data_dir
print(data_dir)

在这个目录下面会有很多项目自带的图片，所以说上面的读取自带的图片的信息内容可以使用下面的代码，结果是一样的效果。

from skimage import data_dir
img = io.imread(data_dir+'\coffee.png')
io.imshow(img)

三、保存图片

可以使用io.imsave()保存图片内容信息，在这个方法下面可以转换图片的保存格式

from skimage import io,data
img = io.imread('data.jpg')
io.imshow(img)
io.imsave('E:\Test\data.png',img)

四、图片信息

可以直接打印出来图片信息。

from skimage import io,data
img = data.coffee()
print('type:',type(img))
print('shape:',img.shape)
print('宽度:',img.shape[0])
print('高度:',img.shape[1])
print('通道数:',img.shape[2])
print('最大值:',img.max())
print('最小值:',img.min())
print('平均值:',img.mean())

三.图像像素的访问与裁剪

图片内容是以numpy的array形式存储在内存中的，对numpy的访问都可以用来对图片信息的访问，彩色图片是三维的，可以使用img[i,j,k],其中i表示的是行，j表示的是列，k表示的通道数（RGB，1，2，3），对于灰度图可以使用gray[i,j]来访问，其中i,j的含义和彩色图信息内容是一样的。

1. 显示咖啡图片的30行60列图片信息

from skimage import io,data
img = data.coffee()
print(img[30,60,1])

2.分别显示彩色图片的红绿蓝的单道图片信息R,G,B

from skimage import io,data
img = data.coffee()
io.imshow(img[:,:,0])

from skimage import io,data
img = data.coffee()
io.imshow(img[:,:,1])

3. 对图片随机添加椒盐噪声

   给图片随机产生1500个像素的噪声干扰

from skimage import io,data
img = data.coffee()
# plt.imshow(img)
row,col,dim = img.shape
print(x,y,z)
for i in range(1500):
    x = np.random.randint(0,row)
    y = np.random.randint(0,col)
    img[x,y,:] = 255
plt.figure()
plt.imshow(img)

这里用到了numpy包里的random来生成随机数，randint(0,cols)表示随机生成一个整数，范围在0到cols之间。
用img[x,y,:]=255这句来对像素值进行修改，将原来的三通道像素值，变为255。255是白色，0是黑色。

4. 对图片进行裁剪

   可以随意的对图片进行修剪，只显示某些部位

from skimage import io,data
img = data.coffee()
plt.imshow(img[200:300,500:600,:])

5. 图片信息二值化

   将以上图片信息转换成为二值图像信息

from skimage import io,data,color
img = data.coffee()
img_gray = color.rgb2gray(img)
row,col = img_gray.shape
for i in range(row):
    for j in range(col):
        if img_gray[i,j] <= 0.5:
            img_gray[i,j] = 0
        else:
            img_gray[i,j] = 1
plt.imshow(img_gray)

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。

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

一、图像数据类型及转换

在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.coffee()
print(img.dtype.name)

uint8

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

• 1、unit8转float

from skimage import io,data,img_as_float
img = data.coffee()
print(img.dtype.name)
# plt.imshow(img)
img_f = img_as_float(img)
print(img_f.dtype.name)
plt.imshow(img_f)

uint8
float64

• 2、float转uint8

from skimage import io,data,img_as_ubyte
import numpy as np
img = np.array([0,0.5,0.8,1])
print(img.dtype.name)
img_c = img_as_ubyte(img)
print(img_c .dtype.name)

float64
uint8

二、颜色空间及其转换

除了直接改变数据类型之外，还可以通过图像的颜色空间转换来改变数据类型。常用的颜色空间有灰度空间、rgb空间、hsv空间和cmyk空间。颜色空间转换以后，图片类型都变成了float型。

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

rgb转灰度图

from skimage import io,data,color,data_dir
img = data.coffee()
print(data_dir)
plt.imshow(img)
img_gray = color.rgb2gray(img)
plt.imshow(img_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颜色空间。

from skimage import io,data,color,data_dir
img = data.coffee()
img_gray = color.convert_colorspace(img,'rgb','hsv')
plt.imshow(img_gray)

可以使用skimage.color.label2rgb(arr)给图片进行着色

form skimage import io,data,color
img = data.coffee()
img_c = color.rgb2gray(img)
row,col = img_c.shape()
labels = np.zeros([row,col])
for i in range(row):
	for j in range(col):
		if img_c[i,j] < 0.4:
			labels [i,j] = 0
		elif img_c[i,j] < 0.75:
			labels [i,j] = 1
		else:
			labels [i,j] = 2
img_label = color.label2rgb(labels )
plt.imshow(img_label )

5.图像的绘制

io.imshow()其实就是数据分析三剑客里面的matplotlib绘图，等价于 matplotlib.pyplot.imshow()
等价于下面的代码

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

imshow()的函数格式为：matplotlib.pyplot.imshow(X, cmap=None)
其中x表示要绘制的图像或者数组
cmap：颜色图谱，默认绘制为RGB(A)颜色空间
其他的颜色空间图谱如下：

使用方式：

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

一般情况下最后需要调用plt.show()方法，但是不写也不影响结果

from skimage import io,data
img = data.coffee()
print(type(img))
re = io.imshow(img)
print(type(re))
io.show()

使用figure和subplot展示图片信息和子图信息

from skimage import io,data
import matplotlib.pyplot as plt
img = data.coffee()
plt.figure(num='coffee',figsize=(8,8))

plt.subplot(2,2,1)
plt.title('Origin image')
plt.imshow(img)

plt.subplot(2,2,2)
plt.title('Gray')
plt.imshow(img[:,:,0],plt.cm.gray)
plt.axis('off')

plt.subplot(2,2,3)
plt.title('R')
plt.imshow(img[:,:,1],plt.cm.gray)
plt.axis('off')

plt.subplot(2,2,4)
plt.title('G')
plt.imshow(img[:,:,2],plt.cm.gray)
plt.axis('off')
plt.show()

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)表示将屏幕化成4块，两行，两列，当前是显示的第一块，等价于plt.subplot(221)

上面的方式可以使用subplots()方式也能实现类似的效果

from skimage import io,data,color
import matplotlib.pyplot as plt
img = data.coffee()
img_hsv = color.rgb2hsv(img)

fig,axes = plt.subplots(2,2,figsize=(7,6))
ax1,ax2,ax3,ax4 = axes.ravel()

ax1.imshow(img_hsv)
ax1.set_title('Origin image')
ax1.axis('off')

ax2.imshow(img_hsv[:,:,0])
ax2.set_title('R')
ax2.axis('off')

ax3.imshow(img_hsv[:,:,1])
ax3.set_title('G')
ax3.axis('off')

ax4.imshow(img_hsv[:,:,2])
ax4.set_title('B')
ax4.axis('off')


plt.show()

使用subplots()创建格式如下：比上面多一个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()

返回的内容

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()

（6）：图像的批量处理

对图片的批量处理中，可以使用循环来处理也可以使用程序自带的图片集合来处理。

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

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

from skimage import io,data_dir
str = data_dir+'/*.png'
coll = io.ImageCollection(str)
print(len(coll))
plt.imshow(coll[10])
plt.show()

从结果可以看出，一共有30张.png图片，在skimage.io模块下ImageCollection()的方法下读取图片。然后展示的是第10张图片

如果想要展示.jpg图片，可以使用以下格式读取.png和.jpg类型的图片

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格式的图片都读取出来。如果还想读取存放在其它地方的图片，也可以一并加进去，只是中间同样用冒号来隔开。

批量处理转换成为灰度图。需要自己写一个函数进行转换。

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

七.图像的形变与缩放

1.图像的形变与缩放需要使用skimage中的transform模块，里面有很多方法

语法格式：skimage.transform.resize(image, output_shape)
image:需要修改的图片内容
output_shape：这个是改变之后的size内容

from skimage import data,transform
img = data.coffee()
img_resize = transform.resize(img,(80,80))
plt.figure()

plt.subplot(121)
plt.title('Old image')
plt.imshow(img)

plt.subplot(122)
plt.title('New')
plt.imshow(img_resize)
plt.show()

2、按比例缩放rescale

函数格式为：skimage.transform.rescale(img,scale[, ...])
img:为原始的图像内容。
scale：可以是float型，也可以是tuple型，表示的是缩放的行和列

from skimage import data,transform
img = data.coffee()
print(img.shape)
img_scale = transform.rescale(img,0.5)
print(img_scale.shape)

plt.subplot(121)
plt.title("Old")
plt.imshow(img)

plt.subplot(122)
plt.title("Rescale")
plt.imshow(img_scale[:,:,0])
plt.show()

3、旋转 rotate
函数：skimage.transform.rotate(img,angle[, ...],resize=False)
img：原始的图像
angle：旋转的角度
resize:是否更改角度

from skimage import data,transform
img = data.coffee()
print("原始的图像:",img.shape)
img_rotate = transform.rotate(img,60)
print("旋转之后的:",img_rotate.shape)

plt.figure()
plt.subplot(121)
plt.title("Old")
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title("New")
plt.imshow(img_rotate,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()

八.对比度与亮度调整

图像的亮度和对比度放在exposure里面。
1、gamma调整

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

1. g>1,新图像比原图像暗
2. g<1,新图像比原图像亮
3. g=1,这个是默认值，表示原图像
   函数格式：skimage.exposure.adjust_gamma(image,gramma=1)

from skimage import exposure,data,img_as_float
img = data.moon()
img1 = img_as_float(img)

img_gam1 = exposure.adjust_gamma(img1,2) #调暗
img_gam2 = exposure.adjust_gamma(img1,0.5) #调亮
plt.figure("Color change",figsize=(8,8))

plt.subplot(131)
plt.title("Origin image")
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(132)
plt.title("gamma=2")
plt.imshow(img_gam1)
plt.axis('off')

plt.subplot(133)
plt.title("gamma=0.5")
plt.imshow(img_gam2)
plt.axis('off')
plt.imshow(img)
plt.show()

2、log对数调整
实现原理和gamma相反
原理：I=log(I)

from skimage import data,exposure,img_as_float
img = img_as_float(data.moon())
img_log = exposure.adjust_log(img)
plt.figure('Log compose',figsize=(8,8))

plt.subplot(121)
plt.title("Origin image")
plt.axis('off')
plt.imshow(img)

plt.subplot(122)
plt.title("Log")
plt.axis('off')
plt.imshow(img_log)

plt.show()

3、判断图像对比度是否偏低
函数：is_low_contrast(img)
返回一个bool值

from skimage import data,exposure
img = data.moon()
res = exposure.is_low_contrast(img)
res

结果为：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

from skimage import exposure
import numpy as np
data = np.array([23,50,166],dtype=np.uint8)
data1 = exposure.rescale_intensity(data)
data1

结果是：array([ 0, 48, 255], dtype=uint8)
即像素最小值由23变为0，最大值由166变为255，整体进行了拉伸，但是数据类型没有变，还是uint8

float类型的范围是[0.0,1.0],对float进行rescale_intensity 调整后，范围变为[0,1],而不是[0,255]
img_as_float()函数将unit8类型转换为float型,还可以直接1.0*

from skimage import exposure
import numpy as np
data = np.array([23,50,166],dtype=np.uint8)
data1 = exposure.rescale_intensity(img*1.0)
data1

结果是：array([0. , 0.18881119, 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)
image：原始数据
numpy中也提供了histogram两者的含义类似
返回一个tuple（hist, bins_center), 前一个数组是直方图的统计量，后一个数组是每个bin的中间值。

from skimage import exposure,data
import numpy as np
img = data.camera()*1.0
hist1 = np.histogram(img,bins=2)#用numpy包计算直方图
hist2 = exposure.histogram(img,nbins=2)
plt.imshow(img)
print(hist1)
print(hist2)
img

(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、绘制直方图
这个就是用到我们数据分析三件套里面的matplot.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 numpy as np
img = data.coins()
data_arr = img.flatten()
plt.hist(data_arr,bins=256,density=1,edgecolor='None',facecolor='red')
plt.figure("Hist")
plt.show()

flatten()函数是将numpy中的二维数组转换成一维数组的，进行扁平化铺开。

mat=[[1 2 3
　　　 4 5 6]]

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

mat=[1 2 3 4 5 6]

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

from skimage import data
import matplotlib.pyplot as plt
img=data.coffee()
ar=img[:,:,0].flatten()
plt.hist(ar,bins=256,density=True,facecolor='r',edgecolor='r')
ag=img[:,:,1].flatten()
plt.hist(ag,bins=256,density=True, facecolor='g',edgecolor='g')
ab=img[:,:,2].flatten()
plt.hist(ab,bins=256,density=True, facecolor='b',edgecolor='b')
plt.show()

注意点：现在函数里面已经没有hold这个参数

4、直方图均衡化

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

from skimage import data,exposure
img = data.moon()
plt.figure('Hist',figsize=(8,8))

arr = img.flatten()
plt.subplot(221)
plt.imshow(img,plt.cm.gray)#原始图像
# plt.axis('off')
plt.subplot(222)
plt.hist(arr,bins=256, density=1,edgecolor='None',facecolor='red') #原始图像直方图

img1=exposure.equalize_hist(img)
img_data = img1.flatten()
plt.subplot(223)
plt.imshow(img1,plt.cm.gray)

plt.subplot(224)
plt.hist(img_data,bins=256, density=1,edgecolor='None',facecolor='red')


plt.show()

使用exposure.equalize_hist(img)会将图片展示的更加清楚。

十. 图像简单滤波

对图像进行滤波，可以有两种效果：一种是平滑滤波，用来抑制噪声；另一种是微分算子，可以用来检测边缘和特征提取。

skimage中对图像进行滤波是通过filters进行滤波

1、sobel算子
sobel算子可用来检测边缘，函数格式为：skimage.filters.sobel(image, mask=None)

from skimage import filters
img = data.camera()

plt.subplot(121)
plt.title('Orgin image')
plt.imshow(img)
plt.axis('off')

plt.subplot(122)
plt.title("Sobel")
img_subel = filters.sobel(img)
plt.imshow(img_subel)
plt.axis('off')
plt.show()

2、roberts算子
roberts算子和sobel算子一样，用于检测边缘

调用格式:skimage.filters.roberts(image)

from skimage import filters,data
img = data.camera()
plt.subplot(121)
plt.title('Origin image')
plt.axis('off')
plt.imshow(img)

plt.subplot(122)
plt.title('Roberts image')
plt.axis('off')
img_roberts = filters.roberts(img)
plt.imshow(img_roberts)

plt.show()

3、scharr算子
功能同sobel，调用格式：edges = filters.scharr(img)

from skimage import filters,data
img = data.camera()
plt.subplot(121)
plt.title('Origin image')
plt.axis('off')
plt.imshow(img)

plt.subplot(122)
plt.title('Scharr image')
plt.axis('off')
img_roberts = filters.scharr(img)
plt.imshow(img_roberts)

plt.show()

4、prewitt算子
功能同sobel，调用格式：edges = filters.prewitt(img)

from skimage import filters,data
img = data.camera()
plt.subplot(121)
plt.title('Origin image')
plt.axis('off')
plt.imshow(img)

plt.subplot(122)
plt.title('Roberts image')
plt.axis('off')
img_roberts = filters.prewitt(img)
plt.imshow(img_roberts)

plt.show()

5、canny算子

canny算子也是用于提取边缘特征，但它不是放在filters模块，而是放在feature模块
函数格式为：skimage.feature.canny(img,sigma=1.0)
可以修改sigma的值来调整效果

from skimage import feature,data
img = data.camera()
plt.figure('Image',figsize=(18,18))

plt.subplot(141)
plt.axis('off')
plt.title("Orgin image")
plt.imshow(img)

plt.subplot(142)
plt.axis('off')
plt.title('Sigma = 1')
img_sigma1 = feature.canny(img,sigma=1.0)
plt.imshow(img_sigma1)

plt.subplot(143)
plt.axis('off')
plt.title('Sigma = 2')
img_sigma2 = feature.canny(img,sigma=2.0)
plt.imshow(img_sigma2)

plt.subplot(144)
plt.axis('off')
plt.title('Gray')
img_gray = feature.canny(img)
plt.imshow(img_gray,plt.cm.gray)
plt.show()

从结果可以看出，sigma越小，边缘线条越细小。
6、gabor滤波
gabor滤波可用来进行边缘检测和纹理特征提取。
函数格式为：skimage.filters.gabor_filter(image, frequency)
通过修改frequency值来调整滤波效果，返回一对边缘结果，一个是用真实滤波核的滤波结果，一个是想象的滤波核的滤波结果。

from skimage import data,filters
import matplotlib.pyplot as plt
img = data.camera()
filt_real, filt_imag = filters.gabor(img,frequency=0.6)   

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

plt.subplot(121)
plt.title('filt_real')
plt.imshow(filt_real,plt.cm.gray)  

plt.subplot(122)
plt.title('filt-imag')
plt.imshow(filt_imag,plt.cm.gray)

plt.show()

7、gaussian滤波
多维的滤波器，是一种平滑滤波，可以消除高斯噪声。
调用函数为：skimage.filters.gaussian_filter(image, sigma)

from skimage import data,filters
import matplotlib.pyplot as plt
img = data.astronaut()
edges1 = filters.gaussian(img,sigma=0.4)   #sigma=0.4
edges2 = filters.gaussian(img,sigma=5)   #sigma=5

plt.figure('gaussian',figsize=(8,8))
plt.subplot(121)
plt.imshow(edges1,plt.cm.gray)  

plt.subplot(122)
plt.imshow(edges2,plt.cm.gray)

plt.show()

可见sigma越大，过滤后的图像越模糊
8.median
中值滤波，一种平滑滤波，可以消除噪声。

需要用skimage.morphology模块来设置滤波器的形状。

from skimage import data,filters
import matplotlib.pyplot as plt
from skimage.morphology import disk
img = data.camera()
edges1 = filters.median(img,disk(5))
edges2= filters.median(img,disk(9))

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

plt.subplot(121)
plt.imshow(edges1,plt.cm.gray)  

plt.subplot(122)
plt.imshow(edges2,plt.cm.gray)

plt.show()

9、水平、垂直边缘检测
上边所举的例子都是进行全部边缘检测，有些时候我们只需要检测水平边缘，或垂直边缘，就可用下面的方法。

水平边缘检测：sobel_h, prewitt_h, scharr_h

垂直边缘检测： sobel_v, prewitt_v, scharr_v

from skimage import data,filters
import matplotlib.pyplot as plt
img = data.camera()
edges1 = filters.sobel_h(img)  
edges2 = filters.sobel_v(img) 

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

plt.subplot(121)
plt.imshow(edges1,plt.cm.gray)  

plt.subplot(122)
plt.imshow(edges2,plt.cm.gray)

plt.show()

上边左图为检测出的水平边缘，右图为检测出的垂直边缘。
10、交叉边缘检测
可使用Roberts的十字交叉核来进行过滤，以达到检测交叉边缘的目的。这些交叉边缘实际上是梯度在某个方向上的一个分量。

其中一个核：

0 1
-1 0
对应的函数：

roberts_neg_diag(image）

from skimage import data,filters
import matplotlib.pyplot as plt
img =data.camera()
dst =filters.roberts_neg_diag(img) 

plt.figure('filters',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title('filted image')
plt.imshow(dst,plt.cm.gray)

另外一个核：

1 0
0 -1
对应函数为：

roberts_pos_diag(image）

from skimage import data,filters
import matplotlib.pyplot as plt
img =data.camera()
dst =filters.roberts_pos_diag(img) 

plt.figure('filters',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title('filted image')
plt.imshow(dst,plt.cm.gray)

十一.图像自动阈值分割

图像阈值分割是一种广泛应用的分割技术，利用图像中要提取的目标区域与其背景在灰度特性上的差异，把图像看作具有不同灰度级的两类区域(目标区域和背景区域)的组合，选取一个比较合理的阈值，以确定图像中每个像素点应该属于目标区域还是背景区域，从而产生相应的二值图像。

在skimage的库中，阈值分割在filters的模块中，可以手动进行分割也可以自动让系统帮我们进行分割。

1、threshold_otsu
基于Otsu的阈值分割方法，函数调用格式：skimage.filters.threshold_otsu(image, nbins=256)

from skimage import data,filters
img = data.camera()
img_otsu = filters.threshold_otsu(img) #返回一个阈值
dst = (img <= img_otsu) * 1.0 #根据阈值进行分割

plt.figure("Thresh",figsize=(8,8))
plt.subplot(121)
plt.title('Origin image')
plt.axis('off')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title('Img_otsu image')
plt.imshow(dst,plt.cm.gray)
plt.axis('off')
plt.show()

2、threshold_yen
方法：thresh = filters.threshold_yen(image)
使用方式和上面的使用方式类似

from skimage import data,filters
img = data.camera()
img_threshold_yen = filters.threshold_yen(img)
thresh = (img <= img_threshold_yen) * 1.0

plt.figure("hist",figsize=(8,8))
plt.subplot(121)
plt.title('Origin')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title("After change")
plt.imshow(thresh,plt.cm.gray)
plt.show()

返回阈值为198，分割如下图：

3、threshold_li
使用方式和上面的一样。语法格式：thresh = filters.threshold_li(image)

from skimage import data,filters
img = data.camera()
img_threshold_li = filters.threshold_li(img)
thresh = (img <= img_threshold_li) * 1.0

plt.figure("hist",figsize=(8,8))
plt.subplot(121)
plt.title('Origin')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title("After change")
plt.imshow(thresh,plt.cm.gray)
plt.show()

返回阈值64.5

4、threshold_isodata
阈值计算方法：
threshold = (image[image <= threshold].mean() +image[image > threshold].mean()) / 2.0

语法格式：thresh = filters.threshold_isodata(image)

from skimage import data,filters
img = data.camera()
img_threshold_isodata = filters.threshold_isodata(img)
thresh = (img <= img_threshold_isodata) * 1.0

plt.figure("hist",figsize=(8,8))
plt.subplot(121)
plt.title('Origin')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title("After change")
plt.imshow(thresh,plt.cm.gray)
plt.show()

5、threshold_adaptive
调用函数为：skimage.filters.threshold_adaptive(image, block_size, method='gaussian'）
block_size: 块大小，指当前像素的相邻区域大小，一般是奇数（如3，5，7。。。）

method: 用来确定自适应阈值的方法，有’mean’, ‘generic’, ‘gaussian’ 和 ‘median’。省略时默认为gaussian

该函数直接访问一个阈值后的图像，而不是阈值。

from skimage import data,filters
import matplotlib.pyplot as plt
image = data.camera()
dst =filters.threshold_adaptive(image, 15)  #返回一个阈值图像

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

plt.subplot(121)
plt.title('original image')
plt.imshow(image,plt.cm.gray)

plt.subplot(122)
plt.title('binary image')
plt.imshow(dst,plt.cm.gray)

plt.show()

改为另外两个阈值

dst1 =filters.threshold_adaptive(image,31,'mean') 
dst2 =filters.threshold_adaptive(image,5,'median')

目前低版本已经不支持threshold_adaptive这个方法，需要查询资料更改其他的方式

十二. 基本图形的绘制

图形包括线条，圆形，椭圆形，多边形等，在skimage包中，在绘制图形时是draw模块，不要和绘制图像搞混了。

from skimage import draw,data
img = data.chelsea()
plt.imshow(img)
rr,cc = draw.line(50,100,200,200)#（50，100）->(200,200)
img[rr,cc] = 0
plt.imshow(img,plt.cm.gray)

设置线条颜色：skimage.draw.set_color(img, coords, color)

from skimage import draw,data
import matplotlib.pyplot as plt
img=data.chelsea()
rr, cc =draw.line(50,100,200,200)
draw.set_color(img,[rr,cc],[0,0,196])
plt.imshow(img)

2、画圆
函数格式：skimage.draw.circle(cy, cx, radius）

from skimage import data,draw
img = data.coffee()
rr,cc = draw.circle(100,100,50)#设置圆心和半径，前面的是圆心，后面的是半径
img[rr,cc] = [255,0,0]
plt.imshow(img)
plt.show()

设置红色实心圆

3、多边形
函数格式：skimage.draw.polygon(Y,X)

from skimage import draw,data
img=data.coffee()
Y=np.array([10,10,60,60])
X=np.array([200,400,400,200])#设置了四个顶点
rr, cc=draw.polygon(Y,X)
draw.set_color(img,[rr,cc],[255,0,0])
plt.imshow(img,plt.cm.gray)

4、椭圆

函数格式：skimage.draw.ellipse(cy, cx, yradius, xradius）

from skimage import draw,data
img=data.chelsea()
rr, cc=draw.ellipse(150, 150, 30, 80)
draw.set_color(img,[rr,cc],[255,0,0])
plt.imshow(img,plt.cm.gray)

5、贝塞儿曲线
格式：skimage.draw.bezier_curve(y1,x1,y2,x2,y3,x3,weight)
y1,x1表示第一个控制点坐标

y2,x2表示第二个控制点坐标

y3,x3表示第三个控制点坐标

weight表示中间控制点的权重，用于控制曲线的弯曲度。

from skimage import draw,data
import matplotlib.pyplot as plt
img=data.chelsea()
rr, cc=draw.bezier_curve(150,50,50,280,260,400,2)
draw.set_color(img,[rr,cc],[255,0,0])
plt.imshow(img,plt.cm.gray)

6、画空心圆
和前面的画圆是一样的，只是前面是实心圆，而此处画空心圆，只有边框线。
格式：skimage.draw.circle_perimeter(yx,yc,radius)
yx,yc是圆心坐标，radius是半径

from skimage import draw,data
import matplotlib.pyplot as plt
img=data.chelsea()
rr, cc=draw.circle_perimeter(150,150,50)
draw.set_color(img,[rr,cc],[255,0,0])
plt.imshow(img,plt.cm.gray)

7、空心椭圆
格式：skimage.draw.ellipse_perimeter(cy, cx, yradius, xradius）

from skimage import draw,data
import matplotlib.pyplot as plt
img=data.chelsea()
rr, cc=draw.ellipse_perimeter(150, 150, 30, 80)
draw.set_color(img,[rr,cc],[255,0,0])
plt.imshow(img,plt.cm.gray)

十三.基本形态学滤波

对图像进行形态学变换。变换对象一般为灰度图或二值图，功能函数放在morphology子模块内。
1、膨胀（dilation)
原理：一般是对二值图像处理。找到像素点为1的点，将像素点为1的周围的点设置成和它一样。注意1表示白，0表示黑，膨胀可以扩大白的的范围，压缩黑色的范围。一般用来扩充边缘或填充小的孔洞。
功能函数： skimage.morphology.dilation(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。

from skimage import data
import skimage.morphology as sm
img = data.checkerboard()
des1 = sm.dilation(img,sm.square(5))
des2 = sm.dilation(img,sm.square(15))
plt.figure('hist',figsize=(8,8))

plt.subplot(221)
plt.title("Origin")
plt.imshow(img)

plt.subplot(222)
plt.title("Gray")
plt.imshow(img,plt.cm.gray)

plt.subplot(223)
plt.title("dilation 5")
plt.imshow(des1,plt.cm.gray)

plt.subplot(224)
plt.title("dilation 15")
plt.imshow(des2,plt.cm.gray)

plt.show()

可见滤波器的大小，对操作结果的影响非常大。一般设置为奇数。

除了正方形的滤波器外，滤波器的形状还有一些，现列举如下：

morphology.square: 正方形

morphology.disk: 平面圆形

morphology.ball: 球形

morphology.cube: 立方体形

morphology.diamond: 钻石形

morphology.rectangle: 矩形

morphology.star: 星形

morphology.octagon: 八角形

morphology.octahedron： 八面体

注意，如果处理图像为二值图像（只有0和1两个值），则可以调用：

skimage.morphology.binary_dilation(image, selem=None）

用此函数比处理灰度图像要快。

2、腐蚀（erosion)
函数：skimage.morphology.erosion(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。

和膨胀相反的操作，将0值扩充到邻近像素。扩大黑色部分，减小白色部分。可用来提取骨干信息，去掉毛刺，去掉孤立的像素。

from skimage import data
import skimage.morphology as sm
img = data.checkerboard()
des1 = sm.erosion(img,sm.square(5))
des2= sm.erosion(img,sm.square(15))

plt.figure('Hist',figsize=(6,6))
plt.subplot(221)
plt.title("Origin")
plt.imshow(img)

plt.subplot(222)
plt.title("Gray")
plt.imshow(img,plt.cm.gray)

plt.subplot(223)
plt.title("Erosion 5")
plt.imshow(des1,plt.cm.gray)

plt.subplot(224)
plt.title("Erosion 15")
plt.imshow(des2,plt.cm.gray)
plt.show()

注意，如果处理图像为二值图像（只有0和1两个值），则可以调用：

skimage.morphology.binary_erosion(image, selem=None）用此函数比处理灰度图像要快。

3、开运算（opening)
函数：skimage.morphology.openning(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。
先腐蚀再膨胀，可以消除小物体或小斑块。

from skimage import io,color
import skimage.morphology as sm
import matplotlib.pyplot as plt
img=color.rgb2gray(io.imread('d:/pic/mor.png'))
dst=sm.opening(img,sm.disk(9))  #用边长为9的圆形滤波器进行膨胀滤波

plt.figure('morphology',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(122)
plt.title('morphological image')
plt.imshow(dst,plt.cm.gray)
plt.axis('off')

skimage.morphology.binary_opening(image, selem=None）

用此函数比处理灰度图像要快。

4、闭运算（closing)
函数：skimage.morphology.closing(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。

先膨胀再腐蚀，可用来填充孔洞。

from skimage import io,color
import skimage.morphology as sm
import matplotlib.pyplot as plt
img=color.rgb2gray(io.imread('d:/pic/mor.png'))
dst=sm.closing(img,sm.disk(9))  #用边长为5的圆形滤波器进行膨胀滤波

plt.figure('morphology',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(122)
plt.title('morphological image')
plt.imshow(dst,plt.cm.gray)
plt.axis('off')

注意，如果处理图像为二值图像（只有0和1两个值），则可以调用：

skimage.morphology.binary_closing(image, selem=None）

5、白帽（white-tophat)
函数：skimage.morphology.white_tophat(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。

将原图像减去它的开运算值，返回比结构化元素小的白点

from skimage import io,color
import skimage.morphology as sm
import matplotlib.pyplot as plt
img=color.rgb2gray(io.imread('d:/pic/mor.png'))
dst=sm.white_tophat(img,sm.square(21))  

plt.figure('morphology',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(122)
plt.title('morphological image')
plt.imshow(dst,plt.cm.gray)
plt.axis('off')

6、黑帽（black-tophat)
函数：skimage.morphology.black_tophat(image, selem=None）
selem表示结构元素，用于设定局部区域的形状和大小。

将原图像减去它的闭运算值，返回比结构化元素小的黑点，且将这些黑点反色。

from skimage import io,color
import skimage.morphology as sm
import matplotlib.pyplot as plt
img=color.rgb2gray(io.imread('d:/pic/mor.png'))
dst=sm.black_tophat(img,sm.square(21))  

plt.figure('morphology',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(122)
plt.title('morphological image')
plt.imshow(dst,plt.cm.gray)
plt.axis('off')

十四.高级滤波

方法放在filters.rank子模块内。这些方法需要用户自己设定滤波器的形状和大小，因此需要导入morphology模块来设定。
1、autolevel
这个词在photoshop里面翻译成自动色阶，用局部直方图来对图片进行滤波分级。

该滤波器局部地拉伸灰度像素值的直方图，以覆盖整个像素值范围。

格式：skimage.filters.rank.autolevel(image, selem）
selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img = data.camera()
img_rgb = color.rgb2gray(img)
img_sfr = sfr.autolevel(img_rgb,disk(5))  #半径为5的圆形滤波器
plt.figure('Hist',figsize=(8,8))
plt.subplot(131)
plt.title("Origin image")
plt.axis('off')
plt.imshow(img)

plt.subplot(132)
plt.title("Origin gray")
plt.axis('off')
plt.imshow(img_rgb,plt.cm.gray)

plt.subplot(133)
plt.title("Autolevel")
plt.axis('off')
plt.imshow(img_sfr,plt.cm.gray)

plt.show()

2、bottomhat 与 tophat
bottomhat: 此滤波器先计算图像的形态学闭运算，然后用原图像减去运算的结果值，有点像黑帽操作。

bottomhat: 此滤波器先计算图像的形态学开运算，然后用原图像减去运算的结果值，有点像白帽操作。格式：
skimage.filters.rank.bottomhat(image, selem）
skimage.filters.rank.tophat(image, selem）
selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img =color.rgb2gray(data.camera())
auto =sfr.bottomhat(img, disk(5))  #半径为5的圆形滤波器

plt.figure('filters',figsize=(8,8))
plt.subplot(121)
plt.title('origin image')
plt.imshow(img,plt.cm.gray)

plt.subplot(122)
plt.title('filted image')
plt.imshow(auto,plt.cm.gray)

3、enhance_contrast
对比度增强。求出局部区域的最大值和最小值，然后看当前点像素值最接近最大值还是最小值，然后替换为最大值或最小值。

函数： enhance_contrast(image, selem）
selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img = data.camera()
img_gray = color.rgb2gray(img)
img_enhance_contrast = sfr.enhance_contrast(img_gray,disk(5))  #半径为5的圆形滤波器

plt.figure('Hist',figsize=(8,8))
plt.subplot(121)
plt.title("Origin image")
plt.imshow(img)
plt.axis('off')

plt.subplot(122)
plt.title('Enhance_contrast')
plt.imshow(img_enhance_contrast)
plt.axis('off')
plt.show()

4、entropy
求局部熵，熵是使用基为2的对数运算出来的。该函数将局部区域的灰度值分布进行二进制编码，返回编码的最小值。
函数格式：entropy(image, selem）

selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img = data.camera()
img_gray = color.rgb2gray(img)
img_entropy = sfr.entropy(img_gray,disk(5))

plt.figure('Hist',figsize=(8,8))
plt.subplot(221)
plt.title("Origin image")
plt.imshow(img_gray)
plt.axis('off')

plt.subplot(222)
plt.title("Change image")
plt.imshow(img_entropy)
plt.axis('off')

plt.subplot(223)
plt.title("Origin image gray")
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(224)
plt.title("Image gray entropy")
plt.imshow(img_entropy,plt.cm.gray)
plt.axis('off')

plt.show()

5、equalize
均衡化滤波。利用局部直方图对图像进行均衡化滤波。

函数格式：equalize(image, selem）

selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img = data.camera()
img_gray = color.rgb2gray(img)
img_equalize = sfr.equalize(img_gray,disk(5))

plt.figure('Hist',figsize=(8,8))
plt.subplot(221)
plt.title("Origin image")
plt.imshow(img)
plt.axis('off')

plt.subplot(222)
plt.title("Change image")
plt.imshow(img_equalize)
plt.axis('off')

plt.subplot(223)
plt.title("Origin image gray")
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(224)
plt.title("Image gray entropy")
plt.imshow(img_equalize,plt.cm.gray)
plt.axis('off')

plt.show()

6、gradient
返回图像的局部梯度值（如：最大值-最小值），用此梯度值代替区域内所有像素值。

函数格式：gradient(image, selem）

selem表示结构化元素，用于设定滤波器。

from skimage import data,color
import matplotlib.pyplot as plt
from skimage.morphology import disk
import skimage.filters.rank as sfr
img = data.camera()
img_gray = color.rgb2gray(img)
img_gradient = sfr.gradient(img_gray,disk(5))

plt.figure('Hist',figsize=(8,8))
plt.subplot(221)
plt.title("Origin image")
plt.imshow(img)
plt.axis('off')

plt.subplot(222)
plt.title("Change image")
plt.imshow(img_gradient)
plt.axis('off')

plt.subplot(223)
plt.title("Origin image gray")
plt.imshow(img,plt.cm.gray)
plt.axis('off')

plt.subplot(224)
plt.title("Image gray entropy")
plt.imshow(img_gradient,plt.cm.gray)
plt.axis('off')

plt.show()

7、其它滤波器
滤波方式很多，下面不再一一详细讲解，仅给出核心代码，所有的函数调用方式都是一样的。

最大值滤波器（maximum):返回图像局部区域的最大值，用此最大值代替该区域内所有像素值。

dst =sfr.maximum(img, disk(5))
最小值滤波器（minimum)：返回图像局部区域内的最小值，用此最小值取代该区域内所有像素值。

dst =sfr.minimum(img, disk(5))
均值滤波器（mean) : 返回图像局部区域内的均值，用此均值取代该区域内所有像素值。

dst =sfr.mean(img, disk(5))
中值滤波器（median): 返回图像局部区域内的中值，用此中值取代该区域内所有像素值。

dst =sfr.median(img, disk(5))
莫代尔滤波器（modal) : 返回图像局部区域内的modal值，用此值取代该区域内所有像素值。

dst =sfr.modal(img, disk(5))
otsu阈值滤波（otsu): 返回图像局部区域内的otsu阈值，用此值取代该区域内所有像素值。

dst =sfr.otsu(img, disk(5))
阈值滤波（threshhold): 将图像局部区域中的每个像素值与均值比较，大于则赋值为1，小于赋值为0，得到一个二值图像。

dst =sfr.threshold(img, disk(5))
减均值滤波（subtract_mean): 将局部区域中的每一个像素，减去该区域中的均值。

dst =sfr.subtract_mean(img, disk(5))
求和滤波（sum) :求局部区域的像素总和，用此值取代该区域内所有像素值。

dst =sfr.sum(img, disk(5))