最大流与最小割（Maxflow与Mincut）

传统图像主要分割算法：

1. 基于阈值的分割
   

    （1）固定阈值分割

    （2）直方图双峰法

    （3）迭代阈值图像分割

    （4）自适应阈值图像分割

    （5）最佳阈值法

2.基于边缘的分割

    （1）Canny边缘检测器

    （2）Harris角点检测器

    （3）Sift检测器

    （4）Surf检测器

3.基于区域的分割

    （1）种子区域生长法

    （2）区域分裂合并法

    （3）分水岭法

4.基于图论的分割

    （1）GraphCut图割

    （2）GrabCut分割和抠图

5.基于能量泛函的分割

    （1）参数主动轮廓模型

    （2）ASM

    （3）AAM

    （4）CLM

    （5）GAC

      该文章讲述的最大流与最小割实际上就是图论分割的主要思想。将图像映射为带权无向图，把像素视作节点，将图像分割问题看作是图的顶点划分问题，利用最小剪切准则得到图像的最佳分割。

最大流算法

       最大流算法就像水管水流，如何保证S点到T点的水流量最大。其中点与点之间的表示水管最大容量。

       最大流解法有很多，例如Ford-Fulkerson算法，Edmond-Karp 算法，Dinic算法等。

Ford-Fulkerson算法

 原始图

剩余流量图

       在剩余流量图中随便找一条从s到t的路线

       减去最小容量

       然后构建反向箭头

       接着再找一条从s到t的路线，重复上面的计算

       继续找新路线

       此时已经找不到新的路径从s到t，结束进程。

       再利用公式flow = capacity - residual

 - =

       既可以得出最大流5。

       代码实现：

class Edge():
    ''' 流网络中的边 '''


    def __init__(self, v, w, cap, flow=0):
        '''
        定义一条边 v→w
        :param v: 起点
        :param w: 终点
        :param cap: 容量
        :param flow: v→w上的流量
        '''
        self.v, self.w, self.cap, self.flow = v, w, cap, flow


    def other_node(self, p):
        ''' 返回边中与p相对的另一顶点 '''
        return self.v if p == self.w else self.w


    def residual_cap_to(self, p):
        '''
        计算残存边的剩余容量
        如果p=w，residual_cap_to(p)返回 v→w 的剩余容量
        如果p=v，residual_cap_to(p)返回 w→v 的剩余容量
        '''
        return self.cap - self.flow if p == self.w else self.flow


    def moddify_flow(self, p, x):
        ''' 将边的流量调整x '''
        if p == self.w:  # 如果 p=w，将v→w的流量增加x
            self.flow += x
        else:  # 否则将v→w的流量减少x
            self.flow -= x


    def __str__(self):
        return str(self.v) + '→' + str(self.w)




class Network():
    ''' 流网络 '''


    def __init__(self, E: list, s: int, t: int):
        '''
        :param E: 边集
        :param s: 原点
        :param t: 汇点
        :return:
        '''
        self.E, self.s, self.t = E, s, t


    def edges_from(self, v):
        ''' 从v顶点流出的边 '''
        return [edge for edge in self.E if edge.v == v]


    def edges_to(self, v):
        ''' 流入v顶点的边 '''
        return [edge for edge in self.E if edge.w == v]


    def edges(self, v):
        ''' 连接v顶点的所有边 '''
        return self.edges_from(v) + self.edges_to(v)


    def flows_from(self, v):
        '''v顶点的流出量 '''
        edges = self.edges_from(v)
        return sum([e.flow for e in edges])


    def flows_to(self, v):
        ''' v顶点的流入量 '''
        edges = self.edges_to(v)
        return sum([e.flow for e in edges])


    def check(self):
        ''' 源点的流出是否等于汇点的流入 '''
        return self.flows_from(self.s) == self.flows_to(self.t)


    def display(self):
        if self.check() is False:
            print('该网络不符合守恒定律')
            return
        print('%-10s%-8s%-8s' % ('边', '容量', '流'))
        for e in self.E:
            print('%-10s%-10d%-8s' %
                  (e, e.cap, e.flow if e.flow < e.cap else str(e.flow) + '*'))




class FordFulkerson():
    def __init__(self, G: Network):
        self.G = G
        self.max_flow = 0  # 最大流


    class Node:
        ''' 用于记录路径的轨迹 '''


        def __init__(self, w, e: Edge, parent):
            '''
            :param w: 顶点
            :param e: 从上一顶点流入w的边
            :param parent: 上一顶点
            '''
            self.w, self.e, self.parent = w, e, parent


    def dfs(self):
        ''' 获取网络中的一条增广路径 '''
        path = None
        visited = set()  # 被访问过的顶点
        visited.add(self.G.s)
        q = []
        q.append(self.Node(self.G.s, None, self.G.t))
        tempmaxflow = 1e10
        while len(q):
            node_v = q.pop(0)
            v = node_v.w
            label = 0
            for e in self.G.edges(v):  # 遍历连接v的所有边
                w = e.other_node(v)  # 边的另一顶点，e的指向是v→w
                # v→w有剩余容量且w没有被访问过
                if e.residual_cap_to(w) > 0 and w not in visited:
                    visited.add(w)
                    node_w = self.Node(w, e, node_v)
                    q.append(node_w)
                    if w == self.G.t:  # 到达了汇点
                        path = node_w
                        label = 1
                        break
            if label == 1:  # 到达了汇点
                break
        if path is None:
            tempmaxflow = 0
            return tempmaxflow
        node = path
        while node.parent != self.G.t:  # 计算增广路径上的最小剩余量
            w, e = node.w, node.e
            tempmaxflow = min(tempmaxflow, e.residual_cap_to(w))
            node = node.parent
        node = path
        while node.parent != self.G.t:  # 修改残存网
            w, e = node.w, node.e
            e.moddify_flow(w, tempmaxflow)
            node = node.parent
        return tempmaxflow


    def start(self):
        ''' 增广路径最大流算法主体方法 '''
        while True:
            tempmaxflow = self.dfs()  # 找到一条增广路径
            if tempmaxflow ==0:
                break
            self.max_flow += tempmaxflow  # 扩充最大流


    def display(self):
        print('最大网络流 = ', self.max_flow)
        print('%-10s%-8s%-8s' % ('边', '容量', '流'))
        for e in self.G.E:
            print('%-10s%-10d%-8s' %
                  (e, e.cap, e.flow if e.flow < e.cap else str(e.flow) + '*'))




E = [Edge(1, 2, 4), Edge(1, 3, 2), Edge(2, 4, 2), Edge(2, 5, 4),
     Edge(2, 3, 1), Edge(3, 5, 2), Edge(4, 6, 3), Edge(5, 6, 3)]
s, t = 1, 6
G = Network(E, s, t)
ford_fullkerson = FordFulkerson(G)
ford_fullkerson.start()
ford_fullkerson.display()

       Ford-Fulkerson算法的时间复杂度较高，接下来讲述一种使用较为广泛，时间复杂度低的Dinic算法。

Dinic算法

       Dinic算法首先根据剩余流量图建立一个Level Graph，如下：

       然后在level graph上寻找阻塞流，再将其映射回原先的residual graph中。

       然后在新的residual graph中再次建立level graph图。

       再寻找阻塞流，然后再映射回residual graph。如此不断循环，直到在新生成的level graph中找不到从s到t的阻塞流。

       再利用公式flow = capacity - residual

-=

       最大流量为19。

       代码实现

class Edge():
    ''' 流网络中的边 '''


    def __init__(self, v, w, cap, flow=0):
        '''
        定义一条边 v→w
        :param v: 起点
        :param w: 终点
        :param cap: 容量
        :param flow: v→w上的流量
        '''
        self.v, self.w, self.cap, self.flow = v, w, cap, flow


    def other_node(self, p):
        ''' 返回边中与p相对的另一顶点 '''
        return self.v if p == self.w else self.w


    def residual_cap_to(self, p):
        '''
        计算残存边的剩余容量
        如果p=w，residual_cap_to(p)返回 v→w 的剩余容量
        如果p=v，residual_cap_to(p)返回 w→v 的剩余容量
        '''
        return self.cap - self.flow if p == self.w else self.flow


    def moddify_flow(self, p, x):
        ''' 将边的流量调整x '''
        if p == self.w:  # 如果 p=w，将v→w的流量增加x
            self.flow += x
        else:  # 否则将v→w的流量减少x
            self.flow -= x


    def __str__(self):
        return str(self.v) + '→' + str(self.w)




class Network():
    ''' 流网络 '''


    def __init__(self, E: list, s: int, t: int):
        '''
        :param E: 边集
        :param s: 原点
        :param t: 汇点
        :return:
        '''
        self.E, self.s, self.t = E, s, t


    def edges_from(self, v):
        ''' 从v顶点流出的边 '''
        return [edge for edge in self.E if edge.v == v]


    def edges_to(self, v):
        ''' 流入v顶点的边 '''
        return [edge for edge in self.E if edge.w == v]


    def edges(self, v):
        ''' 连接v顶点的所有边 '''
        return self.edges_from(v) + self.edges_to(v)


    def flows_from(self, v):
        '''v顶点的流出量 '''
        edges = self.edges_from(v)
        return sum([e.flow for e in edges])


    def flows_to(self, v):
        ''' v顶点的流入量 '''
        edges = self.edges_to(v)
        return sum([e.flow for e in edges])


    def check(self):
        ''' 源点的流出是否等于汇点的流入 '''
        return self.flows_from(self.s) == self.flows_to(self.t)


    def display(self):
        if self.check() is False:
            print('该网络不符合守恒定律')
            return
        print('%-10s%-8s%-8s' % ('边', '容量', '流'))
        for e in self.E:
            print('%-10s%-10d%-8s' %
                  (e, e.cap, e.flow if e.flow < e.cap else str(e.flow) + '*'))




class FordFulkerson():
    def __init__(self, G: Network):
        self.G = G
        self.max_flow = 0  # 最大流


    class Node:
        ''' 用于记录路径的轨迹 '''


        def __init__(self, w, e: Edge, parent):
            '''
            :param w: 顶点
            :param e: 从上一顶点流入w的边
            :param parent: 上一顶点
            '''
            self.w, self.e, self.parent = w, e, parent


    def bfs(self):
        visited = {self.G.s}
        tempvisited = {self.G.s}
        q = []
        q.append(self.Node(self.G.s, None, self.G.t))
        q.append("end")
        NewE = []
        label = 0
        while len(q)>1:
            node_v = q.pop(0)
            if node_v=="end":
                q.append("end")
                visited = tempvisited.copy()
                continue
            v = node_v.w
            for e in self.G.edges(v):  # 遍历连接v的所有边
                w = e.other_node(v)  # 边的另一顶点，e的指向是v→w
                if e.residual_cap_to(w) > 0 and w not in visited and e not in NewE:
                    tempvisited.add(w)
                    node_w = self.Node(w, e, node_v)
                    q.append(node_w)
                    NewE.append(e)
                    if w == self.G.t:  # 到达了汇点
                        label = 1


        return Network(NewE,self.G.s,self.G.t),label


    def dfs(self,NewNetwork):
        ''' 获取网络中的一条增广路径 '''
        path = None
        path2 = None
        visited = set()  # 被访问过的顶点
        visited.add(self.G.s)
        q = []
        q.append(self.Node(self.G.s, None, self.G.t))
        q2 = []
        q2.append(self.Node(self.G.s, None, self.G.t))
        tempmaxflow = 1e10
        while len(q):
            node_v = q.pop(0)
            node_v2 = q2.pop(0)
            v = node_v.w
            label = 0
            for e in NewNetwork.edges(v):  # 遍历连接v的所有边
                w = e.other_node(v)  # 边的另一顶点，e的指向是v→w
                e2 = [edge for edge in self.G.E if edge==e][0]
                # v→w有剩余容量且w没有被访问过
                if e.residual_cap_to(w) > 0 and w not in visited:
                    visited.add(w)
                    node_w = self.Node(w, e, node_v)
                    q.append(node_w)
                    node_w2 = self.Node(w, e2, node_v2)
                    q2.append(node_w2)


                    if w == self.G.t:  # 到达了汇点
                        path = node_w
                        path2 = node_w2
                        label = 1
                        break
            if label == 1:  # 到达了汇点
                break
        if path is None:
            tempmaxflow = 0
            return tempmaxflow
        node = path
        while node.parent != self.G.t:  # 计算增广路径上的最小剩余量
            w, e = node.w, node.e
            tempmaxflow = min(tempmaxflow, e.residual_cap_to(w))
            node = node.parent
        node = path2
        while node.parent != self.G.t:  # 修改残存网
            w, e = node.w, node.e
            e.moddify_flow(w, tempmaxflow)
            node = node.parent
        return tempmaxflow


    def start(self):
        while True:
            newnet,label = self.bfs()
            if label==0:
                break
            while True:
                tempmaxflow = self.dfs(newnet)  # 找到一条增广路径
                if tempmaxflow == 0:
                    break
                self.max_flow += tempmaxflow  # 扩充最大流




    def display(self):
        print('最大网络流 = ', self.max_flow)
        print('%-10s%-8s%-8s' % ('边', '容量', '流'))
        for e in self.G.E:
            print('%-10s%-10d%-8s' %
                  (e, e.cap, e.flow if e.flow < e.cap else str(e.flow) + '*'))




E = [Edge(1, 2, 10), Edge(1, 3, 10), Edge(2, 4, 4), Edge(2, 5, 8),
     Edge(2, 3, 2), Edge(3, 5, 9), Edge(4, 6, 10), Edge(5, 6, 10),Edge(5, 4, 6)]
s, t = 1, 6
G = Network(E, s, t)
ford_fullkerson = FordFulkerson(G)
ford_fullkerson.start()
ford_fullkerson.display()

最小割算法

       最小割实际上就是使用的最大流的计算结果。

       最大流与最小割之间转化：将最大流的剩余容量图画出来，然后重起点s出发，将可以连在一块的设为s，另一边即为t

总结：

       最大流与最小割是图论分割的基础。接下来我们将继续探讨最大流与最小割如何在图像上实现分割。例如graph cut等。

参考文献：

https://www.its203.com/article/qq_35885429/107226535

https://github.com/wangshusen/AdvancedAlgorithms