【参考】opencv文档
Contours Hierarchy
关于边界的继承结构，例如边界的父子结构
使用 cv2.findContours()，我们需要选择边界回溯模式，例如：cv2.RETR_LIST 或者 cv2.RETR_TREE
函数得到的三个数组，第一个是图片，第二个是边界，第三个是继承结构 hierarchy，一般我们都只用后面两个。
形式如：
python:
contours, hierarchy = cv2.findContours(img,
cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
有时一些图片对象在不同的位置上，但有时候，一些图形会在另一些图形之中，被包含在内部。
例如：黑色区域就被包含在白色区域中，而白色区域外面又有黑色区域，这样就把外层称为是 父层(红色)，内层称为是孩子层（绿色）。
这样一来，我们就可以找出不同的形状间的关系了，例如我们可以分辨出一个边界是如何和其他边界联系的了，例如它是否是一些边界的父边界，或者是另一些边界的孩子边界，这就叫做hierarchy
例如：
说明：
在这张图片里，0，1，2边界是最外层的边界，称为0层（绿色），或者简单地说，他们在同一层次上（没有互相之间的包含关系）
下一层是2a，它是层2的子层，注意是白框内部的部分！我们这里说的一直是边界！！所以它是层1（粉色）。
类似的，边界3是2a的子层，是层2（蓝色），
3a是3的子层，是层3（红色）
最后是4，5层，他们是3a层的子层，是最后一层，是层4（黄色）
所以每个边界都有关于它是哪一个层次的信息，记录结构为：[Next, Previous, First_Child, Parent]
[下一个，上一个，第一个孩子层，父层（上一层）]
参考java版本：Java OpenCV findContours函数RETR_CCOMP轮廓顺序
ds[0]->同层级的下一个轮廓(不存在为-1)
ds[1]->同层级的上一个轮廓(不存在为-1)
ds[2]->第一个子轮廓(不存在为-1)
ds[3]->父轮廓(不存在为-1)
例如：
对于边界0，它的下一个同级边界是边界1，上一个同级轮廓没有，第一个子轮廓没有，没有父轮廓，所以是
[1,-1,-1,-1]
边界2的上一个同级边界是边界1，下一个同级边界没有，第一个子轮廓是2a，没有父轮廓，所以是
[-1,1,2a,-1]
不同的边界flag表示不一样的意思：
cv2.RETR_LIST, cv2.RETR_TREE, cv2.RETR_CCOMP, cv2.RETR_EXTERNAL
1. RETR_LIST
父子结构都不管了，他们只是单纯的边界结构，他们都属于同一层。所以得到的结果是：
>>> hierarchy
2 array([[[ 1, -1, -1, -1],
3 [ 2, 0, -1, -1],
4 [ 3, 1, -1, -1],
5 [ 4, 2, -1, -1],
6 [ 5, 3, -1, -1],
7 [ 6, 4, -1, -1],
8 [ 7, 5, -1, -1],
9 [-1, 6, -1, -1]]])
2. RETR_EXTERNAL
这个模式只返回外层边界，所有的子层都不要了
在这个规则下，只考虑“最老的人”，其他人全都不考虑。
1 >>> hierarchy
2 array([[[ 1, -1, -1, -1],
3 [ 2, 0, -1, -1],
4 [-1, 1, -1, -1]]])
当你只要外层边界的时候，这个标志位很有用。
3. RETR_CCOMP
这个标志会返回全部的边界，但是会把它们分为两层，可以算是一种简化吧，例如：
用两种颜色标志就是下面这样的：一层绿色一层粉色
所以可以看到只有两层结构，要么是外层要么是里层，
1 >>> hierarchy
2 array([[[ 3, -1, 1, -1],
3 [ 2, -1, -1, 0],
4 [-1, 1, -1, 0],
5 [ 5, 0, 4, -1],
6 [-1, -1, -1, 3],
7 [ 7, 3, 6, -1],
8 [-1, -1, -1, 5],
9 [ 8, 5, -1, -1],
10 [-1, 7, -1, -1]]])
注意：
ds[0]->同层级的下一个轮廓(不存在为-1)
ds[1]->同层级的上一个轮廓(不存在为-1)
ds[2]->第一个子轮廓(不存在为-1)
ds[3]->父轮廓(不存在为-1)
这里为什么父层不是为0或者-1呢？
因为每层标志都必须用真实标志，所以层也要按照父子关系来，需要用每一层的真实标号。
如果只想显示父层或者子层，可以通过层与层记录之间的关系来达到，隔一层记录一次，或者仅仅遍历某层之间的上一个和下一个。
例如，
从hierachy[0][0][0]开始，有上一个轮廓不存在，下一个轮廓是3，
所以查询轮廓hierachy[0][0][3]，可见[ 5, 0, 4, -1]，同级别的下一个轮廓是5，查询hierachy[0][0][5]，下一个轮廓是hierachy[0][0][7] [ 8, 5, -1, -1],，下一个轮廓是hierachy[0][0][8]， [-1, 7, -1, -1]，下一个轮廓是-1不存在，得到了0，3，5，7，8，都是一层，和图片相符，而且有子轮廓，是外层（父层）
同理，1，2，4，6是一层，都是子层（内层）
代码实现：
OpenCV中findContours轮廓提取一个边缘只对应的一个轮廓
opencv轮廓提取的时候，图像中一条边缘有查找到两个轮廓。当然只提取最外轮廓是不会出现重复情况，但设置提取所有轮廓会出现两个轮廓，对于利用得到的轮廓进一步处理带来不必要的麻烦，所以需要从一条轮廓开始，然后找他的同级链，直到找到结尾。
这样的处理方式就不会有双层轮廓的问题了。
由于截图有些噪点，边框白色部分又比较小，显示出来的效果一般。
当我把图片反转为~img时，用于检测表格：
表格检测代码：
import cv2
if __name__ =='__main__':
image = cv2.imread('mask1.jpg')
img = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
img = cv2.adaptiveThreshold(~img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, -2)
contours,hierachy = cv2.findContours(img, cv2.RETR_CCOMP,cv2.CHAIN_APPROX_SIMPLE)
# 查找内层的例子：
i=0
hierach_id = 0
inner_class =[]
# 一直搜索到找到没有子轮廓的结构，且注意搜索长度不能超过边界数目
while(hierachy[0][i][2]!=-1 and hierachy[0][i][1]==-1 and i<len(contours) and hierachy[0][i][3]!=-1):
hierach_id = i
i+=1
print(hierach_id,hierachy[0][hierach_id])
while(hierachy[0][hierach_id][0]!=-1):
inner_class.append(contours[hierach_id])
hierach_id=hierachy[0][hierach_id][0]
print(hierach_id,hierachy[0][hierach_id])
for cnt in inner_class: # 画图
cv2.drawContours(image,[cnt],0,(122,122,0),3)
cv2.imshow('img',image)
cv2.waitKey(10000)
把
img = cv2.adaptiveThreshold(~img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, -2)
改为：
img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, -2)
也就是图片黑白反转回来就是检测外侧边框了：
最后一个4. RETR_TREE
It even tells, who is the grandpa, father, son, grandson and even beyond… 😃.
也就说，保存了全部的层次结构，
例如:
得到的结构：
1 >>> hierarchy
2 array([[[ 7, -1, 1, -1],
3 [-1, -1, 2, 0],
4 [-1, -1, 3, 1],
5 [-1, -1, 4, 2],
6 [-1, -1, 5, 3],
7 [ 6, -1, -1, 4],
8 [-1, 5, -1, 4],
9 [ 8, 0, -1, -1],
10 [-1, 7, -1, -1]]])
用途：
ds[0]->同层级的下一个轮廓(不存在为-1)
ds[1]->同层级的上一个轮廓(不存在为-1)
ds[2]->第一个子轮廓(不存在为-1)
ds[3]->父轮廓(不存在为-1)
这个其实就可以随意diy使用了，想要哪层要哪层，
保存了全部的信息，
如果需要查找最里面的孔洞，直接找
hierachy[0][i][2]==-1 and hierachy[0][i][1]==-1
的层就行。
例如下面的图片：
这是用 RETR_CCMP标志位得到的。但是，现在我不需要红色标注的边界，我需要绿色标注的边界，也就是最小的方格子里面的内容。
如何获取这些内容呢？
首先我们观察到，他们都是最里层，所以有：
# 无子轮廓 无上一个轮廓，找到同辈的起点
hierachy[0][i][2]==-1 and hierachy[0][i][1]==-1
找到第一个最内层，然后找寻它的同层就好了。
——理论上是这样，然而经过反复实验：
很明显的其中有一些边框是存在子结构的，
但是hierachy[0][i][2]也是-1,
可能这个标志位的注释和实现其实也是存在问题的吧。。
即使用自己生成的基本无噪点的图片也不行：
而且仔细看，还有两条重复的边缘，不知道是什么意思。。。
可能还是得看opencv的源码才能揭开这个未解之谜了。
不过好事情是，我们还有其他方法来提取这些小格子，例如，先近似为矩形，利用cv2.approxPolyDP(contour, 3, True) # 趋近矩形 然后再计算是否有重叠，有重叠的就不是小格子，没有重叠的就是最小的格子。
图上我们就可以看到，格子之间不是重叠的，某些边缘可能包含了这些格子，但恰巧这些边缘都是我们不要的。
用这样的办法去除非小格子的部分。
还有许多其他办法，我就不一一赘述了。
具体实现我做好了，由于项目相关，这个又比较简单，我就不单独写了。
最内层搜索代码：
import cv2
if __name__ =='__main__':
image = cv2.imread('test2.jpg')
img = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
img = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 15, -2)
contours,hierachy = cv2.findContours(img, cv2.RETR_CCOMP,cv2.CHAIN_APPROX_SIMPLE)
# 查找最内层的例子：
hierach_ids = []
inner_class =[]
# 一直搜索到找到没有子轮廓的结构，且注意搜索长度不能超过边界数目，且需要找到第一个,
# 这样的边界可能有多个，因为不存在包含的关系，需要完整的搜索。
for i in range(len(contours)):
if(hierachy[0][i][2]==-1 and hierachy[0][i][1]==-1):
hierach_ids.append(i)
for hierach_id in hierach_ids:
print(hierachy[0][hierach_id])
inner_class.append(contours[hierach_id])
idx = hierachy[0][hierach_id][0]
while(hierachy[0][idx][0]!=-1):
inner_class.append(contours[idx])
idx=hierachy[0][idx][0]
print(hierachy[0][idx])
for cnt in inner_class:
cv2.drawContours(image,[cnt],0,(122,122,0),2)
cv2.imshow('img',image)
cv2.waitKey(10000)
cv2.imwrite('save.png',image)
用contours做连通域掩膜
拓展连接：用contours做连通域掩膜
findContour的规律：
规律
只有将内部轮廓全部找出才继续进行同级轮廓查找
结论
1. 不同层级的轮廓顺序从里到外
2. 同级轮廓根据轮廓最上像素点Y座标从大到小排序（图片的从下到上），若存在Y座标相同情况下根据X座标从大到小排序（图片的从右到左）
3. 若一个轮廓内有子轮廓，回先查找该轮廓的所有子轮廓后才会继续同级轮廓的查找。（有点像深搜）
4. RETR_TREE是分层的所以同层级的下一个轮廓(ds[0])，同层级的上一个轮廓(ds[1])需要注意是否为同级轮廓