def main():
args = parse_arguments()
n = args.nodes
m = args.edges
seed_number = args.seed
if seed_number is None:
seed_number = randint(1000)
directed = args.directed
generator = get_graph(args.graph, n, m, directed, seed_number)
g, source, target = generator.generate()
print("Source " + str(source) + " Target " + str(target))
gt.graph_draw(g,
edge_pen_width=g.ep.cap,
output="graph_initial.pdf",
vertex_text=g.vertex_index,
edge_text=g.ep.cap)
solver = get_algorithm(args.algorithm, g)
solution = solver.get_max_flow(source, target)
print("The maximum flow is " + str(solution))
if args.compare:
generator = get_graph(args.graph, n, m, directed, seed_number)
g, source, target = generator.generate()
cap = g.ep.cap
res = gt.push_relabel_max_flow(g, source, target, cap)
res.a = cap.a - res.a # the actual flow
max_flow = sum(res[e] for e in target.in_edges())
print("The maximum flow of graph-tool is " + str(max_flow))
def test_max_flow_scale_free_directed(n):
seed_number = randint(1, 1000)
generator = ScaleFree(n, directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
solver = GoldbergWave(graph)
max_flow = solver.get_max_flow(source, target)
generator = ScaleFree(n, directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
def test_max_flow_triangulation_delaunay_directed(n):
seed_number = randint(1, 1000)
generator = Triangulation(n, type="delaunay", directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
solver = Goldberg(graph)
max_flow = solver.get_max_flow(source, target)
generator = Triangulation(n, type="delaunay", directed=True, seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
def test_max_flow_scale_random_undirected(size):
seed_number = randint(1, 1000)
generator = Random(size[0], size[1], directed=False, seed_number=seed_number)
graph, source, target = generator.generate()
solver = GoldbergWave(graph)
max_flow = solver.get_max_flow(source, target)
generator = Random(size[0], size[1], directed=False, seed_number=seed_number)
graph, source, target = generator.generate()
res = gt.push_relabel_max_flow(graph, source, target, graph.ep.cap)
res.a = graph.ep.cap.a - res.a # the actual flow
gt_max_flow = sum(res[e] for e in target.in_edges())
assert max_flow == gt_max_flow
def max_flow(self, src, tgt):
g = self.graph
pos = self.pos
cap = g.ep['capacity']
#self.dump_edge_property(cap)
#self.draw_graph(cap, 'visualisation/current-capacity.pdf')
src, tgt = g.vertex(src), g.vertex(tgt)
res = gt.push_relabel_max_flow(g, src, tgt, cap)
#res = gt.boykov_kolmogorov_max_flow(g, src, tgt, cap)
res.a = cap.a - res.a
max_flow = sum(res[e] for e in tgt.in_edges())
#self.draw_graph(res, 'visualisation/current-max-flow.pdf')
return res, max_flow
def max_flow(self, src, tgt):
g = self.graph
pos = self.pos
cap = g.ep['capacity']
#self.dump_edge_property(cap)
#self.draw_graph(cap, 'visualisation/current-capacity.pdf')
src, tgt = g.vertex(src), g.vertex(tgt)
res = gt.push_relabel_max_flow(g, src, tgt, cap)
#res = gt.boykov_kolmogorov_max_flow(g, src, tgt, cap)
res.a = cap.a - res.a
max_flow = sum(res[e] for e in tgt.in_edges())
#self.draw_graph(res, 'visualisation/current-max-flow.pdf')
return res, max_flow
def gcut(clusters):
import graph_tool.all as gt
import numpy as np
g=gt.Graph()
wt=g.new_edge_property("long double")
g.add_vertex(old[0]*old[1]+2)
s=g.vertex(0)
t=g.vertex(1)
beta=5
for i in range(old[0]):
print(i)
for j in range(old[1]):
e=g.add_edge(s,cur(i,j))
wt[e]=-np.log(clusters[i][j][1])
e=g.add_edge(cur(i,j),t)
wt[e]=-np.log(clusters[i][j][0])
if i>0:
e=g.add_edge(cur(i-1,j),cur(i,j))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i-1][j]))
e=g.add_edge(cur(i,j),cur(i-1,j))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i-1][j]))
if j!=old[1]-1:
e=g.add_edge(cur(i,j),cur(i,j+1))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i][j+1]))
e=g.add_edge(cur(i,j+1),cur(i,j))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i][j+1]))
if i!=old[0]-1:
e=g.add_edge(cur(i,j),cur(i+1,j))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i+1][j]))
e=g.add_edge(cur(i+1,j),cur(i,j))
wt[e]=np.exp(-beta*norm(clusters[i+1][j], clusters[i][j]))
if j!=0:
e=g.add_edge(cur(i,j),cur(i,j-1))
wt[e]=np.exp(-beta*norm(clusters[i][j],clusters[i][j-1]))
e=g.add_edge(cur(i,j-1), cur(i,j))
wt[e]=np.exp(-beta*norm(clusters[i][j], clusters[i][j-1]))
res = gt.push_relabel_max_flow(g, s, t, wt)
part = gt.min_st_cut(g, s, wt, res)
print("Graph cut done.")
ans=np.ndarray((old[0],old[1]), dtype=bool)
print(ans.shape)
for i in range(old[0]):
for j in range(old[1]):
ans[i][j]=part[g.vertex(cur(i,j))]
imshow(ans)
return
def get_real_max_flow(graph, source, target):
cap = graph.ep.cap
res = gt.push_relabel_max_flow(graph, source, target, cap)
res.a = cap.a - res.a # the actual flow
return sum(res[e] for e in target.in_edges())
gt.graph_draw(g, edge_pen_width=gt.prop_to_size(g.ep.cap, mi=1, ma=5, power=1),
output="cf/cf_capacities.pdf", vertex_text=g.vertex_index, edge_text=g.ep.cap)
# source = g.vertex(0)
# target = g.vertex(3)
solver = Goldberg(g)
solution = solver.get_max_flow(source, target)
print("Il max flow trovato da Golberg è:", solution)
labels = g.new_vertex_property("string")
for vertex in g.vertices():
labels[vertex] = str(g.vertex_index[vertex]) + "(" + str(g.vp.height[vertex]) + "," + str(
g.vp.excess[vertex]) + ")"
gt.graph_draw(g, edge_pen_width=gt.prop_to_size(g.ep.residual, mi=1, ma=5, power=1),
output="cf/max-flow-our-solution.pdf", vertex_text=labels, edge_text=g.ep.residual)
generator = Triangulation(50, type="delaunay", directed=True, seed_number=seed_number)
g, source, target = generator.generate()
cap = g.ep.cap
res = gt.push_relabel_max_flow(g, source, target, cap)
res.a = cap.a - res.a # the actual flow
max_flow = sum(res[e] for e in target.in_edges())
print("Il max flow trovato da GraphTool è:", max_flow)
gt.graph_draw(g, edge_pen_width=gt.prop_to_size(res, mi=1, ma=5, power=1),
output="cf/max-flow-library-solution.pdf", vertex_text=g.vertex_index, edge_text=res)
# Number of edges
M = 10
seed_number = 45
generator = Triangulation(N, directed=False, seed_number=seed_number)
g, src, tgt = generator.generate()
cap = g.ep.cap
gt.graph_draw(g,
edge_pen_width=gt.prop_to_size(cap, mi=1, ma=1, power=1),
output="graph_to_solve.pdf",
vertex_text=g.vertex_index,
edge_text=g.ep.cap)
# using GraphTool algorithm, find the solution to test and print the resulting graph
res = gt.push_relabel_max_flow(g, src, tgt, cap)
res.a = cap.a - res.a # the actual flow
max_flow = sum(res[e] for e in tgt.in_edges())
print("Il max flow trovato da GraphTool è:", max_flow)
labels = g.new_edge_property("string")
for edge in g.edges():
labels[edge] = str(res[edge]) + "/" + str(cap[edge])
gt.graph_draw(g,
edge_pen_width=gt.prop_to_size(res, mi=1, ma=5, power=1),
output="max-flow-library-solution.pdf",
vertex_text=g.vertex_index,
edge_text=labels)
# using WaveImplementation, find the solution to test and print the resulting graph
solver = GoldbergWave(graph=g)
