本章节介绍图像分割方面的算法：分水岭算法，grabcut算法，meanshift算法等知识。
图像分割：将前景物体从背景中提取出来。
图像分割分为传统图像分割和基于深度学习的图像分割。
传统图像分割有：分水岭算法，grabcut算法，meanshift算法，背景抠出等。
1 分水岭算法
分水岭算法是基于图像形态学和图像结构的来实现的一种分割方法。
在没有背景模板可以用的情况下，分水岭算法首先计算图像的梯度（如查找轮廓），形成的线条组成了山脉或岭，没有纹理的地方形成盆地或山谷；然后从指定的点向盆地灌水，当图像被灌满时，所有有标记的区域就被分割开了。
分水岭算法中涉及到的api：
dist_fg = distanceTransform(img,distanceType,maskSize)
计算img中非0值距离到它最近的0值之间的距离（该函数用来确定前景），返回的和img大小一样的矩阵，矩阵的元素是距离（浮点数）。
img:要处理的图像。 distanceType：计算距离的方式，DIST_L1,DIST_L2。 maskSize：进行扫描时的kernel的大小，L1用3，L2用5。
_, markers = connectedComponents(img,[labels,[connectivity]])
求连通域（img通常是前景图片，该函数用来计算markers），输入图片要求是8位的单通道图片，单通道的值是0-255的整型。用0标记图像的背景，用大于0的整数标记其他的对象。
connectivity：连通方式，4，8（默认）。
markers = watershed(image,markers)
执行分水岭算法（找出图像边界）。返回的maskers做了修改，大于1是前景，1是背景，-1表示边界区域。
markers：它是一个与原始图像大小相同的矩阵，int32数据类型，表示哪些是前景，哪些是背景。分水岭算法将标记为0的区域视为未知区域，标记为1是背景，标记大于1是前景。
分水岭算法练习，提取下面图片中的硬币：
如果直接用形态学方面的知识处理：
#用形态学和与运算提取感兴趣前景
import cv2
import numpy as np
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
_,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) #全局二值化，大津算法自动找阈值
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)) #结构元
erode = cv2.erode(thresh,kernel) #抠出的图略大了一点，腐蚀一下
bit_img = cv2.bitwise_and(img,img,mask=erode) #用与运算提取前景
cv2.imshow('coins',img)
cv2.imshow('erode',erode)
cv2.imshow('bit_img',bit_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
结果如下：
可以基本实现前景硬币提取，但是硬币连接处边缘过度不平滑，用分水岭算法进行处理。
分水岭算法的关键是标记出前景，背景和未知区域，利用形态学的知识找出前景，背景和未知区域：
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.hist(gray.ravel(),bins=256,range=[0,255]) #用plt画直方图，ravel()函数是把多维变一维
plt.show()
#img的图是典型的双峰结构，用大津算法进行二值化处理
_,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) #全局二值化，大津算法自动找阈值
#二值化后的图存在毛边，有小噪点，做一下开运算
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)) #结构元
img_open= cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel,iterations=2)
cv2.imshow('img_open',img_open)
#想办法找到前景和背景
#对img_open进行膨胀操作，找背景
bg = cv2.dilate(img_open,kernel,iterations=2)
cv2.imshow('bg',bg)
#对img_open进行腐蚀操作，找前景,但是从前景图上来看，效果不太好，因为硬币与硬币之间有明显的通道，跟实际（相切）不一样
fg = cv2.erode(img_open,kernel,iterations=2)
cv2.imshow('fg',fg)
#可以通过膨胀减去腐蚀，就是硬币的边界，即未知区域
unkown = cv2.subtract(bg,fg)
cv2.imshow('unkown',unkown)
cv2.waitKey(0)
cv2.destroyAllWindows()
背景没有什么问题，黑色区域全部属于背景，但是前景部分有些白色区域（硬币边缘）不应该被认作前景，因此通过腐蚀来确定前景不太合适，用distanceTransform()来确定前景，然后重新确定前景和未知区域。
import cv2
import numpy as np
import matplotlib.pyplot as plt
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.hist(gray.ravel(),bins=256,range=[0,255]) #用plt画直方图，ravel()函数是把多维变一维
plt.show()
#img的图是典型的双峰结构，用大津算法进行二值化处理
_,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) #全局二值化，大津算法自动找阈值
#二值化后的图存在毛边，有小噪点，做一下开运算
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)) #结构元
img_open= cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel,iterations=2)
# cv2.imshow('img_open',img_open)
#想办法找到前景和背景
#对img_open进行膨胀操作，找背景
bg = cv2.dilate(img_open,kernel,iterations=2)
cv2.imshow('bg',bg)
#对img_open进行腐蚀操作，找前景,但是从前景图上来看，效果不太好，因为硬币与硬币之间有明显的通道，跟实际（相切）不一样
# fg = cv2.erode(img_open,kernel,iterations=2)
# cv2.imshow('fg',fg)
#可以通过膨胀减去腐蚀，就是硬币的边界，即未知区域
# unkown = cv2.subtract(bg,fg)
# cv2.imshow('unkown',unkown)
#通过腐蚀来确定前景不合适，用distanceTransform()来确定前景
dist_fg = cv2.distanceTransform(img_open,cv2.DIST_L2, 5)
#对dist_fg做归一化方便展示结果
dist_fg = cv2.normalize(dist_fg,None,0,1.0,cv2.NORM_MINMAX)
# print('dist_fg.max:',dist_fg.max())
cv2.imshow('dist_fg',dist_fg)
#对dist_fg做二值化处理
_,fg = cv2.threshold(dist_fg,0.6*dist_fg.max(),255,cv2.THRESH_BINARY)
cv2.imshow('fg',fg)
fg = np.uint8(fg) #把fg的数据类型转换位uint8的整型
# print(fg)
unkown = cv2.subtract(bg,fg) #计算未知区域，硬币边缘
cv2.imshow('unkown',unkown)
cv2.waitKey(0)
cv2.destroyAllWindows()
结果如下：
然后把前景，背景和未知区域写进markers中（用connectedComponents函数）：
#connectedComponents要求输入的图片是8位的单通道图片，单通道的值是0-255的整型。这个函数可以计算出标志区域（0标记背景，大于0的整数标记前景）
_,markers = cv2.connectedComponents(fg)
print('markers_max:',markers.max(),'markers_min:',markers.min()) #marks大小和输入图片一样
#因为分水岭算法watershed中是：0是未知区域，1是背景，大于1是前景，markers +1的话，把原来的0变为1即可。
markers += 1
#从markers中筛选出未知区域，然后赋值位0
markers[unkown == 255] = 0 #此时watershed需要的markers已经完成
print(markers.max())
最后执行分水岭算法，抠出硬币：
#执行分水岭算法
markers = cv2.watershed(img,markers) #返回的markers做了修改，边界区域标记为了-1
print('markers:',markers.max(),markers.min())
# img[markers == -1] = [0,0,255] #标记边缘
# # cv2.imshow('img',img)
# img[markers > 1] = [0,255,0] #标记前景
# cv2.imshow('img',img)
#抠出硬币
#mask把要抠图的地方赋值为255，其他位置赋值为0
mask = np.zeros(shape=img.shape[:2],dtype=np.uint8)
mask[markers > 1] = 255
img_coins = cv2.bitwise_and(img,img,mask=mask)
cv2.imshow('img_coins',img_coins)
结果如下：
最终的分水岭算法整体代码如下：
#分水岭算法
import cv2
import numpy as np
import matplotlib.pyplot as plt
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
plt.hist(gray.ravel(),bins=256,range=[0,255]) #用plt画直方图，ravel()函数是把多维变一维
plt.show()
#img的图是典型的双峰结构，用大津算法进行二值化处理
_,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU) #全局二值化，大津算法自动找阈值
#二值化后的图存在毛边，有小噪点，做一下开运算
kernel = cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)) #结构元
img_open= cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel,iterations=2)
# cv2.imshow('img_open',img_open)
#想办法找到前景和背景
#对img_open进行膨胀操作，找背景
bg = cv2.dilate(img_open,kernel,iterations=2)
cv2.imshow('bg',bg)
#对img_open进行腐蚀操作，找前景,但是从前景图上来看，效果不太好，因为硬币与硬币之间有明显的通道，跟实际（相切）不一样
# fg = cv2.erode(img_open,kernel,iterations=2)
# cv2.imshow('fg',fg)
#可以通过膨胀减去腐蚀，就是硬币的边界，即未知区域
# unkown = cv2.subtract(bg,fg)
# cv2.imshow('unkown',unkown)
#通过腐蚀来确定前景不合适，用distanceTransform()来确定前景
dist_fg = cv2.distanceTransform(img_open,cv2.DIST_L2, 5)
#对dist_fg做归一化方便展示结果
dist_fg = cv2.normalize(dist_fg,None,0,1.0,cv2.NORM_MINMAX)
# print('dist_fg.max:',dist_fg.max())
cv2.imshow('dist_fg',dist_fg)
#对dist_fg做二值化处理
_,fg = cv2.threshold(dist_fg,0.6*dist_fg.max(),255,cv2.THRESH_BINARY)
cv2.imshow('fg',fg)
fg = np.uint8(fg) #把fg的数据类型转换位uint8的整型
# print(fg)
unkown = cv2.subtract(bg,fg) #计算未知区域，硬币边缘
cv2.imshow('unkown',unkown)
#connectedComponents要求输入的图片是8位的单通道图片，单通道的值是0-255的整型。这个函数可以计算出标志区域（0标记背景，大于0的整数标记前景）
_,markers = cv2.connectedComponents(fg)
print('markers_max:',markers.max(),'markers_min:',markers.min()) #marks大小和输入图片一样
#因为分水岭算法watershed中是：0是未知区域，1是背景，大于1是前景，markers +1的话，把原来的0变为1即可。
markers += 1
#从markers中筛选出未知区域，然后赋值位0
markers[unkown == 255] = 0 #此时watershed需要的markers已经完成
print(markers.max())
#展示一下markers
markers_copy = markers.copy()
markers_copy[markers == 0] =127 #位置区域
markers_copy[markers >1] = 255 #前景
markers_copy = markers_copy.astype('uint8') #要注意需要把其类型转换位uint8才能展示图片
cv2.imshow('markers_copy',markers_copy)
#执行分水岭算法
markers = cv2.watershed(img,markers) #返回的markers做了修改，边界区域标记为了-1
print('markers:',markers.max(),markers.min())
# img[markers == -1] = [0,0,255] #标记边缘
# # cv2.imshow('img',img)
# img[markers > 1] = [0,255,0] #标记前景
# cv2.imshow('img',img)
#抠出硬币
#mask把要抠图的地方赋值为255，其他位置赋值为0
mask = np.zeros(shape=img.shape[:2],dtype=np.uint8)
mask[markers > 1] = 255
img_coins = cv2.bitwise_and(img,img,mask=mask)
cv2.imshow('img_coins',img_coins)
cv2.waitKey(0)
cv2.destroyAllWindows()
和canny对比：
# 和canny对比
import cv2
import numpy as np
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.Canny(img,100,150)
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
canny只能检测出边缘，不能进行前景提取分割。
和findContours对比（也只能进行轮廓查找和标记）：
#和findContours对比
import cv2
import numpy as np
img = cv2.imread('./coins.png')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU) #二值化
#findContours要求是单通道，0-255的整数的图片，最好是二值化的图片。
imges,contours,_ = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img,contours,-1,[0,0,255],2)
cv2.imshow('gray',gray)
cv2.imshow('thresh',thresh)
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
2 GrabCut 分割
通过交互的方式获取前景物体。
1.用户指定前景的大体区域，剩下的为背景区域。
2.用户可以明确指定某些地方为前景或背景。
3.gradcut采用分段迭代的方法分析前景物体，形成模型树。
4.最后根据权重决定某个像素是前景还是背景。
GradCut主要用到： k均值聚类；高斯混合模型建模（GMM）；max flow/min cut。
GradCut算法的实现基本步骤：
1.在图片中定义（一个或多个）包含物体的矩形。
2.矩形外的区域被自动认为是背景。
3.对于用户定义的矩形区域，可以用背景中的数据来区分它里面的前景和背景区域。
4.用高斯混合模型（GMM）来对前景和背景建模，并将未定义的像素标记为可能的前景或背景。
5.图像中的每一个像素都被看做通过虚拟边与周围像素相连接，而每条边都有一个属于前景或者背景的概率，这是基于它与周边像素颜色上的相似性。
6.每个像素（即算法中的节点）会与一个前景或背景节点连接。
7.在节点完成连接后（可能与背景或前景连接），若节点之间的边属于不同的终端（即一个节点属于属于前景，另一个节点属于背景），则会切断他们之间的边，这样就能将图像各部分分割出来。
opencv中提供的grabcut函数是：gradCut(img,mask,rect,bgdModel,fgdModel,iterCount,[mode]) -> mask,bgdModel,fgdModel
参数说明：
img --待分割的图像，必须是8位3通道，在处理的过程中不会被修改
mask --掩码图像，如果使用掩码进行初始化，那么mask保存初始化掩码信息；在执行分割的时候，也可以将用户交互所设定的前景和背景保存到mask中，
然后再传入gradCut函数；在处理结束之后，mask会保存结果，mask只能取以下四种值: GCD_BGD(=0)，背景；GCD_FGD(=1)，前景；
GCD_PR_BGD(=2)，可能的背景；GCD_PR_FGD(=3)，可能的前景。
rect --用于限定需要进行分割的图像范围，只有该矩形窗口内的图像部分才被处理。
bgdModel --背景模型，如果为None，函数内部会自动创建一个bgdModel；bgdModel必须是单通道浮点型图像，且行数只能为1，列数只能为13*5.
fgdModel --前景模型，如果为None，函数内部会自动创建一个fgdModel；fgdModel必须是单通道浮点型图像，且行数只能为1，列数只能为13*5.
iterCount --迭代次数，必须大于0
mode --用于指示gradCut函数进行什么操作，可选的有：GC_INIT_WITH_RECT(=0),用矩形窗初始化gradCut；GC_INIT_WITH_MASK(=1),用掩码图像初始化gradCut；
GC_EVAL(=2),执行分割。
利用grabcut提取lena图片的人脸区域，python实现如下：
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
img = cv2.imread('./lena2.jpg')
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
print(img.shape)
plt.imshow(img_gray,cmap ='gray')
plt.show()
#取出前景目标矩形框（x,y,w,h）
rect = (200,200,180,190)
mask = np.zeros(img.shape[:2],np.uint8) #生成mask
cv2.grabCut(img,mask,rect,None,None,5,mode=cv2.GC_INIT_WITH_RECT) #使用rect矩形的前景进行计算，mode
print(mask.dtype)
#返回的mask已经做了修改，GCD_BGD(=0)，背景；GCD_FGD(=1)，前景；GCD_PR_BGD(=2)，可能的背景；GCD_PR_FGD(=3)，可能的前景。
mask1 = np.where((mask ==3) | (mask==1),255,0).astype(np.uint8) #mask生成的数据是int32的，转换成uint8后续的与操作才能进行。
# print('mask1',mask1.dtype)
cv2.imshow('mask1',mask1)
output = cv2.bitwise_and(img,img,mask=mask1) #使用与运算
print(output.dtype)
cv2.rectangle(img,(200,200),(380,390),[0,255,0],2)
cv2.imshow('img',img)
cv2.imshow('output',output)
cv2.waitKey(0)
cv2.destroyAllWindows()
左边眼睛没有提取出来，可以第二次使用gradcut，对mask进行修改：
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
img = cv2.imread('./lena2.jpg')
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
print(img.shape)
plt.imshow(img_gray,cmap ='gray')
plt.show()
#取出前景目标矩形框（x,y,w,h）
rect = (200,200,180,190)
mask = np.zeros(img.shape[:2],np.uint8) #生成mask
cv2.grabCut(img,mask,rect,None,None,5,mode=cv2.GC_INIT_WITH_RECT) #使用rect矩形的前景进行计算，mode
print(mask.dtype)
#返回的mask已经做了修改，GCD_BGD(=0)，背景；GCD_FGD(=1)，前景；GCD_PR_BGD(=2)，可能的背景；GCD_PR_FGD(=3)，可能的前景。
mask1 = np.where((mask ==3) | (mask==1),255,0).astype(np.uint8) #mask生成的数据是int32的，转换成uint8后续的与操作才能进行。
# print('mask1',mask1.dtype)
cv2.imshow('mask1',mask1)
output = cv2.bitwise_and(img,img,mask=mask1) #使用与运算
print(output.dtype)
# cv2.rectangle(img,(200,200),(380,390),[0,255,0],2)
#第二次使用gradcut，对mask进行修改
mask[240:290,300:344] = 1 #指定该区域为前景（眼睛区域被认为是背景了）
cv2.grabCut(img,mask,None,None,None,5,mode=cv2.GC_INIT_WITH_MASK) #注意要使用mask的mode来计算
mask2 = np.where((mask ==3) | (mask==1),255,0).astype(np.uint8)
cv2.imshow('mask2',mask2)
output2 = cv2.bitwise_and(img,img,mask=mask2) #使用与运算
# cv2.imshow('img',img)
cv2.imshow('output',output)
cv2.imshow('output2',output2)
cv2.waitKey(0)
cv2.destroyAllWindows()
结果如下：
基本上效果挺好，但是每次需要在代码中指定需要提取的前景矩形框不太方便，可以选择把grabcut封装成一个类，然后通过鼠标操作来选择提取区域的矩形框。
利用鼠标左键移动画框来标记需要提取的区域，然后用grabcut来进行提取（按g键显示提取结果）。
import cv2
import numpy as np
class APP:
def __init__(self,image):
self.image = image
self.img = cv2.imread(self.image)
self.img2 = self.img.copy() #拷贝一份img，用来确保鼠标移动画矩形的时候不干扰原图
self.start_x = 0 #绘制矩形起始点
self.start_y = 0
self.flag_rect =False #是否需要绘制矩形的标志
self.rect = (0,0,0,0)
self.mask = np.zeros(self.img.shape[:2],np.uint8)
self.output = np.zeros(self.img.shape[:2],np.uint8)
def onMouse(self,event,x,y,flags,params):
#按下左键，开始框选前景区域
if event == cv2.EVENT_LBUTTONDOWN:
self.start_x =x
self.start_y =y
self.flag_rect = True
elif event == cv2.EVENT_MOUSEMOVE and self.flag_rect:
self.img = self.img2.copy() #鼠标每次移动的时候再拷贝一份img2到img用于显示（img会一直刷新，所以之前鼠标移动画的不会影响后面）
cv2.rectangle(self.img,(self.start_x,self.start_y),(x,y),[0,0,0],2)
elif event == cv2.EVENT_LBUTTONUP:
cv2.rectangle(self.img,(self.start_x,self.start_y),(x,y),[0,0,255],2)
self.flag_rect = False
#记录绘制矩形的起始点和宽高，后面grabcut用
self.rect = (min(self.start_x,x),min(self.start_y,y),abs(x-self.start_x),abs(y-self.start_y))
#核心逻辑：窗口，回调函数，图片
def run(self):
#绑定鼠标事件
cv2.namedWindow('img')
cv2.setMouseCallback('img',self.onMouse)
while True:
cv2.imshow('img',self.img)
cv2.imshow('output',self.output)
key = cv2.waitKey(1)
if key == 27:
break
elif key ==ord('g'):
cv2.grabCut(self.img2,self.mask,self.rect,None,None,5,mode=cv2.GC_INIT_WITH_RECT)
mask1 = np.where((self.mask ==3) | (self.mask==1),255,0).astype(np.uint8)
self.output = cv2.bitwise_and(self.img2,self.img2,mask=mask1)
cv2.destroyAllWindows()
app =APP('./lena2.jpg')
app.run()
但是这样只能进行初次提取，不能根据结果继续优化，再添加一些其他功能：用grabcut交互提取目标前景，可以用右键单击框定前景区域，然后按g键执行grabcut算法提取roi区域。如果对提取的区域不满意，可以按一下f键，按住鼠标左键拖动，再次添加前景区域；按一下b键，按住鼠标左键拖动，添加背景区域，然后，通过点击enter键或者空格键重新提取roi区域。最后，通过按w键保存提取roi区域的图片，完成后通过q键或者esc键退出。python代码实现如下：
import cv2
import numpy as np
DRAW_BG = {'color': [0,0,0], 'val': 0} # 背景，标记为0
DRAW_FG = {'color': [255,255,255], 'val': 1} # 前景，标记为1
class APP:
def __init__(self,image):
self.image = image
self.img = cv2.imread(self.image)
self.img2 = self.img.copy() #拷贝一份img，用来确保鼠标移动画矩形的时候不干扰原图
self.value = DRAW_FG #默认添加前景区域
self.start_x = 0 #绘制矩形起始点
self.start_y = 0
self.flag_rect =False #是否需要绘制矩形的标志
self.flag_line =False #是否需要添加前景或背景的线
self.rect = (0,0,0,0)
self.mask = np.zeros(self.img.shape[:2],np.uint8) #grabcut的mask
self.output = np.zeros(self.img.shape[:2],np.uint8)
def onMouse(self,event,x,y,flags,params):
#按下右键，开始框选前景区域
if event == cv2.EVENT_RBUTTONDOWN:
self.start_x =x
self.start_y =y
self.flag_rect = True
elif event == cv2.EVENT_MOUSEMOVE and self.flag_rect:
self.img = self.img2.copy() #鼠标每次移动的时候再拷贝一份img2到img用于显示（img会一直刷新，所以之前鼠标移动画的不会影响后面）
cv2.rectangle(self.img,(self.start_x,self.start_y),(x,y),[0,0,0],2)
elif event == cv2.EVENT_RBUTTONUP:
cv2.rectangle(self.img,(self.start_x,self.start_y),(x,y),[0,0,255],2)
self.flag_rect = False
#记录绘制矩形的起始点和宽高，后面grabcut用
self.rect = (min(self.start_x,x),min(self.start_y,y),abs(x-self.start_x),abs(y-self.start_y))
#按下左键，开始添加前景或背景区域
elif event == cv2.EVENT_LBUTTONDOWN:
self.start_x =x
self.start_y =y
self.flag_line = True
elif event == cv2.EVENT_MOUSEMOVE and self.flag_line:
cv2.line(self.img,(self.start_x,self.start_y),(x,y),self.value['color'],6)
cv2.line(self.mask,(self.start_x,self.start_y),(x,y),self.value['val'],6)
self.start_x =x
self.start_y =y
elif event == cv2.EVENT_LBUTTONUP:
cv2.line(self.img,(self.start_x,self.start_y),(x,y),self.value['color'],6)
cv2.line(self.mask,(self.start_x,self.start_y),(x,y),self.value['val'],6)
self.flag_line = False
#核心逻辑：窗口，回调函数，图片
def run(self):
#绑定鼠标事件
cv2.namedWindow('img')
cv2.setMouseCallback('img',self.onMouse)
while True:
cv2.imshow('img',self.img)
cv2.imshow('output',self.output)
key = cv2.waitKey(1)
if key == 27 or key == ord('q'):
break
#按下g键，进行grabcut分割
elif key ==ord('g'):
cv2.grabCut(self.img2,self.mask,self.rect,None,None,5,mode=cv2.GC_INIT_WITH_RECT)
mask1 = np.where((self.mask ==3) | (self.mask==1),255,0).astype(np.uint8)
self.output = cv2.bitwise_and(self.img2,self.img2,mask=mask1)
#按下f键，在已经分割的图像上标记前景区域
elif key == ord('f'):
self.value = DRAW_FG
#按下b键，在已经分割的图像上标记背景区域
elif key == ord('b'):
self.value = DRAW_BG
elif key == 13 or key == 32: #按下enter键，显示重新提取的分割结果
cv2.grabCut(self.img2,self.mask,None,None,None,5,mode=cv2.GC_INIT_WITH_MASK)
mask2 = np.where((self.mask ==3) | (self.mask==1),255,0).astype(np.uint8)
# cv2.imshow('mask2',mask2)
self.output = cv2.bitwise_and(self.img2,self.img2,mask=mask2)
elif key == ord('w'):
cv2.imwrite('./roi.jpg',self.output)
print('save success')
cv2.destroyAllWindows()
app =APP('./lena2.jpg')
app.run()
初次提取roi区域：
多次添加修改前景和背景，进行人脸区域的提取：
3 meanshift图像分割
meanshift严格来说并不是对图像进行分割的，而是在色彩层面进行平滑滤波的，它会中和色彩分布相近的颜色，平滑色彩细节，侵蚀掉面积较小的颜色区域。效果上看可以形成油画风，它以图像上任一点p为圆心，半径为sp，色彩幅值为sr进行不断迭代，经过迭代，将收敛点的像素值代替原来的像素值，从而去除局部相似的纹理，同时保留了边缘等差异较大的特征。
import cv2
import numpy as np
img = cv2.imread('./keys.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
_,thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY | cv2.THRESH_OTSU)
img_canny0 = cv2.Canny(thresh,150,300)
img_meanshift = cv2.pyrMeanShiftFiltering(img,60,60) #空间半径sp和色彩半径sr需要根据实际情况调整（应该是0-100），返回三通道图片
img_canny = cv2.Canny(img_meanshift,150,200) #canny阈值越小，边缘检测越细致
#findContours的输入图片必须是单通道的图
_,contours,_ = cv2.findContours(img_canny,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(img,contours,-1,[0,0,255],2)
# cv2.findContours()
cv2.imshow('canny',np.hstack((img_canny0,img_canny)))
cv2.imshow('img',np.hstack((img,img_meanshift)))
cv2.waitKey(0)
cv2.destroyAllWindows()
进行meanshift之后再进行边缘检测的结果会好很多：
或者进行花园中大面积的不同花草分割效果也会好些：
