def test_mospp_small():
G = Graph()
G.add_vertex(1)
G.add_vertex(2)
G.add_vertex(3)
G.add_vertex(4)
c1 = G.new_edge_property("int")
c2 = G.new_edge_property("int")
e1 = G.add_edge(1, 3)
e2 = G.add_edge(3, 4)
e3 = G.add_edge(1, 2)
e4 = G.add_edge(2, 4)
e5 = G.add_edge(1, 4)
c1[e1] = 1
c1[e2] = 1
c1[e3] = 0
c1[e4] = 0
c1[e5] = 2
c2[e1] = 1
c2[e2] = 1
c2[e3] = 1
c2[e4] = 1
c2[e5] = 0
assert [[G.vertex_index[r] for r in route]
for route in mospp(G.vertex(1), G.vertex(4), c1, c2)
] == [[1, 4], [1, 2, 4]]
class ZonedNetwork:
def __init__(self,
size: Tuple[int] = (10, 10),
field_size: Tuple[int] = (100, 100)):
self.g = Graph(directed=True)
self.n_zones = size[0] * size[1]
self.fwidth = field_size[0]
self.fheight = field_size[1]
self.n_rows = size[0]
self.n_cols = size[1]
self.row_size: float = self.fheight / self.n_rows
self.col_size: float = self.fwidth / self.n_cols
self.g.add_vertex(self.n_zones)
def get_zone(self, coords: Tuple):
r = int(coords[1] / self.row_size)
c = int(coords[0] / self.col_size)
r = min(self.n_rows - 1, r)
c = min(self.n_cols - 1, c)
return self.g.vertex(r * self.n_cols + c)
def add_passes(self, coords_pairs: List[Tuple]):
pairs = [(self.get_zone((x1, y1)), self.get_zone((x2, y2)))
for x1, y1, x2, y2 in coords_pairs]
return self.g.add_edge_list(pairs)
def save(self, file: str):
self.g.save(file, fmt='graphml')
def vytvořím_graph_tool_graf():
from graph_tool.all import Graph
graf = Graph()
u1 = graf.add_vertex()
u2 = graf.add_vertex()
graf.add_edge(u1, u2)
vprop_double = graf.new_vertex_property("double") # Double-precision floating point
vprop_double[graf.vertex(1)] = 3.1416
vprop_vint = graf.new_vertex_property("vector<int>") # Vector of ints
vprop_vint[graf.vertex(0)] = [1, 3, 42, 54]
eprop_dict = graf.new_edge_property("object") # Arbitrary python object. In this case, a dictionary.
eprop_dict[graf.edges().next()] = {"foo": "bar", "gnu": 42}
gprop_bool = graf.new_graph_property("bool") # Boolean
gprop_bool[graf] = True
graf.save('./data/graph_tool.graphml', fmt='xml')
def astar(
G: Graph,
source: int,
target: int,
edge_attribute: EdgePropertyMap,
heuristic,
pos: np.ndarray,
) -> np.ndarray:
"""
Perform A* with given heuristic
Args:
G: graph
source: start vertex
target: end vertex (search terminates here)
edge_attribute: the edge attribute that defines the cost of an edge
heuristic: a function that underestimates the distance from any vertex to the target
pos: positional attribute for vertices
Returns: a list of vertices from the source to the target
"""
# run A*
pred = astar_search(
G,
weight=edge_attribute,
source=source,
visitor=RouteVisitor(target),
heuristic=lambda v: heuristic(v, target, pos),
)[1]
# backtrack through the graph to the source
route = []
v = target
while v != source:
if v == pred[v]:
raise Exception("The start is not connected to the target")
route.append(v)
v = G.vertex(pred[v])
route.append(v)
return route
class Workflow:
def __init__(self, edges, weights):
self.edges = edges
self.graph = Graph()
self.size = len(edges['target'])
self.graph.add_vertex(self.size)
self.weights = weights
# init weights part
self.graph.vp.weights = self.graph.new_vertex_property('int16_t')
for index in range(0, self.size):
self.graph.vp.weights[index] = weights[index]
for source in self.edges['source'].keys():
for target in self.edges['source'][source]:
self._add_edge(source, target)
self.depth_per_node = {x: 0 for x in range(0, self.size)}
self.accum_weights = {x: 0 for x in range(0, self.size)}
self.find_depth()
self.find_accum_weights(self.size - 1)
self.depth = {x: [] for x in set(self.depth_per_node.values())}
for node, depth in self.depth_per_node.items():
self.depth[depth].append(node)
self.routes_t = {}
self.find_routes(self.size - 1, 0, self.routes_t)
self.routes = []
self.transpose_routes(self.size - 1, self.routes_t[self.size - 1])
def _add_edge(self, source, target):
self.graph.add_edge(self.graph.vertex(source),
self.graph.vertex(target))
def show(self, size=1500):
return graph_draw(self.graph,
vertex_text=self.graph.vertex_index,
vertex_font_size=18,
output_size=(size, size),
output="graph.png")
def find_accum_weights(self, actual_node, accum_weight=0):
already_accum_weight = self.accum_weights[actual_node]
self.accum_weights[actual_node] = max(
already_accum_weight, accum_weight + self.weights[actual_node])
for fathers in self.edges['target'][actual_node]:
self.find_accum_weights(fathers, self.accum_weights[actual_node])
def find_depth(self, actual_node=0, actual_depth=0):
self.depth_per_node[actual_node] = max(
self.depth_per_node[actual_node], actual_depth)
for next_node in self.edges['source'][actual_node]:
self.find_depth(next_node, actual_depth + 1)
def find_routes(self, actual_node, weight=0, routes={}):
weight += self.weights[actual_node]
if actual_node != 0:
routes[actual_node] = {}
for fathers in self.edges['target'][actual_node]:
self.find_routes(fathers, weight, routes[actual_node])
else:
routes[actual_node] = weight
def transpose_routes(self, actual_node, routes, path=[]):
if actual_node != 0:
path = path.copy()
path.append(actual_node)
for child in routes.keys():
self.transpose_routes(child, routes[child], path)
else:
self.routes.append({'path': path, 'weight': routes})
def find_cycles(self):
visited = [False for _ in range(0, self.size)]
return self.find_cycles_helper(0, [])
def find_cycles_helper(self, actual_node, rec_list):
if actual_node in rec_list:
print(rec_list, actual_node)
return True
call_this = []
for child in self.edges['source'][actual_node]:
new_rec_list = rec_list.copy()
new_rec_list.append(actual_node)
call_this.append([child, new_rec_list])
return any([self.find_cycles_helper(x[0], x[1]) for x in call_this])
def build_region_closure(g, root, regions, infection_times, obs_nodes, debug=False):
"""return a closure graph on the the components"""
regions = copy(regions)
root_region = {'nodes': {root}, 'head': root, 'head_time': -float('inf')}
regions[len(regions)] = root_region
gc = Graph(directed=True)
for _ in range(len(regions)):
gc.add_vertex()
# connect each region
gc_edges = []
original_edge_info = {}
for i, j in combinations(regions, 2):
# make group i the one with *later* head
if regions[i]['head_time'] < regions[j]['head_time']:
i, j = j, i
if debug:
print('i, j={}, {}'.format(i, j))
# only need to connect head i to one of the nodes in group j
# where nodes in j have time stamp < head i
# then an edge from region j to region i (because j is earlier)
head_i = regions[i]['head']
def get_pseudo_time(n):
if n == root:
return - float('inf')
else:
return infection_times[n]
targets = [n for n in regions[j]['nodes'] if get_pseudo_time(n) < regions[i]['head_time']]
if debug:
print('head_i: {}'.format(head_i))
print('targets: {}'.format(targets))
print('regions[j]["nodes"]: {}'.format(regions[j]['nodes']))
if len(targets) == 0:
continue
visitor = init_visitor(g, head_i)
forbidden_nodes = list(set(regions[i]['nodes']) | (set(regions[j]['nodes']) - set(targets)))
if debug:
print('forbidden_nodes: {}'.format(forbidden_nodes))
# NOTE: count_threshold = 1
cpbfs_search(g, source=head_i,
terminals=targets,
forbidden_nodes=forbidden_nodes,
visitor=visitor,
count_threshold=1)
reachable_targets = [t for t in targets if visitor.dist[t] > 0]
if debug:
print('reachable_targets: {}'.format(reachable_targets))
if len(reachable_targets) == 0:
# cannot reach there
continue
source = min(reachable_targets, key=visitor.dist.__getitem__)
dist = visitor.dist[source]
assert dist > 0
gc_edges.append(((j, i, dist)))
original_edge_info[(j, i)] = {
'dist': dist,
'pred': visitor.pred,
'original_edge': (source, head_i)
}
for u, v, _ in gc_edges:
gc.add_edge(u, v)
eweight = gc.new_edge_property('int')
for u, v, c in gc_edges:
eweight[gc.edge(gc.vertex(u), gc.vertex(v))] = c
return gc, eweight, original_edge_info
class TTC(AbstractMatchingAlgorithm):
"""This class searches for cycles where each student gets his best option.
This takes a list of students, a list of schools and a ruleset
(which is used to calculate priorities).
This works by generating a directed graph, where each student points
at at his best option, and each school points at the student (or students)
with the highest priority.
"""
EDGE_WIDTH_SIZE_FACTOR = 700
"""Size factor (in the image) of each edge that is not part of the main cycle."""
EDGE_WIDTH_CYCLE_SIZE = 10
"""Size factor (in the image) of each edge that takes part of the main cycle."""
def __init__(self,
generate_images=False,
images_folder="TTC_images",
use_longest_cycle=True):
"""Initializes the algorithm.
:param generate_images: If the process generates images or not.
:type generate_images: bool
:param images_folder: Where images are saved.
:type images_folder: str
:param use_longest_cycle: If the algorithm applies the longest cycle available, or the first one encountered.
:type use_longest_cycle: bool
"""
self.generate_images = generate_images
self.images_folder = images_folder
self.use_longest_cycle = use_longest_cycle
self.__graph = None
self.__vertices_by_school_id = None
self.__vertices_by_student_id = None
self.__students_by_id = None
self.__schools_by_id = None
self.__entity_id = None
self.__entity_type = None
def reset_variables(self):
"""Resets all variables."""
self.__graph = Graph()
self.__vertices_by_school_id = {}
self.__vertices_by_student_id = {}
self.__students_by_id = {}
self.__schools_by_id = {}
self.__entity_id = self.__graph.new_vertex_property("int")
self.__graph.vertex_properties["entity_id"] = self.__entity_id
self.__entity_type = self.__graph.new_vertex_property("string")
self.__graph.vertex_properties["entity_type"] = self.__entity_type
def run(self, students, schools, ruleset):
"""Runs the algorithm.
First it creates the graph, then it lists all the cycles available,
after that it selects one cycle, and applies it. Finally, it starts
the process again.
:param students: List of students.
:type students: list
:param schools: List of school.
:type schools: list
:param ruleset: Set of rules used.
:type ruleset: Ruleset
"""
self.reset_variables()
can_improve = True
iteration_counter = 1
while can_improve:
self.structure_graph(students, schools)
cycles = [c for c in all_circuits(self.__graph, unique=True)]
# print("CYCLES", cycles, "iteration", iteration_counter)
cycle_edges = []
if cycles:
for cycle in cycles: # ToDo: Possible optimisation: apply all disjoint cycles at once
for current_v_index in range(len(cycle)):
next_v_index = (current_v_index + 1) % len(cycle)
from_v = self.__graph.vertex(cycle[current_v_index])
target_v = self.__graph.vertex(cycle[next_v_index])
edge = self.__graph.edge(from_v, target_v)
cycle_edges.append(edge)
if self.__entity_type[from_v] == "st":
sel_student = self.__students_by_id[
self.__entity_id[from_v]]
sel_school = self.__schools_by_id[
self.__entity_id[target_v]]
sel_student.assigned_school = sel_school
sel_school.assignation.append(sel_student)
# vertex_school_target_id = self.__entity_id[target_v]
# vertex_school_target = self.__schools_by_id[vertex_school_target_id]
# print("CYCLE: Student", sel_student.id, "School", sel_school.id)
# print("VVV: School {} -> School {} (Student {}) ".format(self.__entity_id[from_v], self.__entity_id[target_v], self.__entity_id[self.__graph.edge(from_v, target_v)]))
if self.generate_images:
self.generate_image(cycle_edges,
iteration_n=iteration_counter)
else:
can_improve = False
self.__graph.clear()
iteration_counter += 1
def structure_graph(self, students, schools):
"""Creates a graph where students points to schools, and schools points to students.
In the graph, each student points at at his best option, and each school points
at the student (or students) with the highest priority.
:param students: List of students.
:type students: list
:param schools:
:type schools: list
"""
if not self.__students_by_id and not self.__schools_by_id:
for student in students:
self.__students_by_id[student.id] = student
for school in schools:
self.__schools_by_id[school.id] = school
for school in schools:
setattr(school, 'preferences',
StudentQueue(school, preference_mode=True))
remaining_students = [
student for student in students if not student.assigned_school
]
for student in remaining_students:
for pref_school in student.preferences:
pref_school.preferences.append(student)
for student in remaining_students:
v_source_student = self.create_vertex_student(student)
pref_school = next(
(school for school in student.preferences if
len(school.assignation.get_all_students()) < school.capacity),
None)
if pref_school:
v_target_school = self.create_vertex_school(pref_school)
self.create_edge(v_source_student, v_target_school)
for school in schools:
if len(school.assignation.get_all_students()) < school.capacity:
v_source_school = self.create_vertex_school(school)
pref_student = next(
iter(school.preferences.get_all_students()), None)
if pref_student:
v_target_student = self.create_vertex_student(pref_student)
self.create_edge(v_source_school, v_target_student)
# graph_draw(self.__graph,
# vertex_text=self.__entity_id, vertex_shape="circle",
# output_size=(1000, 1000), bg_color=[1., 1., 1., 1], output="graph.png")
def create_vertex_student(self, student):
"""Defines a new student as a vertex in the graph (if it did not existed before)."""
if student.id in self.__vertices_by_student_id:
vertex = self.__vertices_by_student_id[student.id]
else:
vertex = self.__graph.add_vertex()
self.__vertices_by_student_id[student.id] = vertex
self.__entity_id[vertex] = student.id
self.__entity_type[
vertex] = "st" # ToDo: There may be other ways to do this.
return vertex
def create_vertex_school(self, school):
"""Defines a new school as a vertex in the graph (if it did not existed before)."""
if school.id in self.__vertices_by_school_id:
vertex = self.__vertices_by_school_id[school.id]
else:
vertex = self.__graph.add_vertex()
self.__vertices_by_school_id[school.id] = vertex
self.__entity_id[vertex] = school.id
self.__entity_type[vertex] = "sc"
return vertex
def create_edge(self, source_v, target_v):
"""Creates a directed edge between two vertices."""
self.__graph.add_edge(source_v, target_v)
def generate_image(self, cycle_edges, iteration_n=0):
"""Generates an image of a graph.
:param cycle_edges: Edges which are part of the main cycle (they will be highlighted in red).
:type cycle_edges: list
:param iteration_n: Number of iteration of the algorithm (this is added in the filename of the image).
:type iteration_n: int
.. DANGER::
This is an experimental feature.
"""
edge_color = self.__graph.new_edge_property("vector<float>")
edge_width = self.__graph.new_edge_property("int")
for edge in self.__graph.edges():
if edge in cycle_edges:
edge_color[edge] = [1., 0.2, 0.2, 0.999]
edge_width[edge] = 7
else:
edge_color[edge] = [0., 0., 0., 0.3]
edge_width[edge] = 4
vertex_shape = self.__graph.new_vertex_property("string")
vertex_size = self.__graph.new_vertex_property("int")
for vertex in self.__graph.vertices():
if self.__entity_type[vertex] == "st":
vertex_shape[vertex] = "circle"
vertex_size[vertex] = 1
else:
vertex_shape[vertex] = "double_circle"
vertex_size[vertex] = 100
# pos = sfdp_layout(self.__graph, C=10, p=5, theta=2, gamma=1)
pos = arf_layout(self.__graph, d=0.2, a=3)
graph_draw(
self.__graph,
pos=pos,
vertex_text=self.__entity_id,
vertex_font_size=
1, # ToDo: Move image related code outside the class.
vertex_fill_color=[0.97, 0.97, 0.97, 1],
vertex_color=[0.05, 0.05, 0.05, 0.95],
vertex_shape=vertex_shape,
edge_color=edge_color,
edge_pen_width=edge_width,
output_size=(1000, 1000),
bg_color=[1., 1., 1., 1],
output=self.generate_filename(iteration_n))
def generate_filename(self, iteration_n): # ToDo: Move this to utils
"""Returns a filename (which is used to generate the images)."""
filename = "Graph (iteration {})".format(
iteration_n) if iteration_n > 0 else "Graph"
output_file = gen_filepath(self.images_folder,
filename=filename,
extension="png")
return output_file
pos = int(spl_line[0])
neg = int(spl_line[1])
cur_weight = pos + coefficient * neg
w1 = spl_line[2].strip(' \n\uefef')
w2 = spl_line[3].strip(' \n\uefef')
if w1 in add_dict or w2 in add_dict:
continue
if w1 not in word_dict:
v1 = pairs_graph.add_vertex()
word_dict[w1] = pairs_graph.vertex_index[v1]
ver_names[v1] = w1
else:
v1 = pairs_graph.vertex(word_dict[w1])
if w2 not in word_dict:
v2 = pairs_graph.add_vertex()
word_dict[w2] = pairs_graph.vertex_index[v2]
ver_names[v2] = w2
else:
v2 = pairs_graph.vertex(word_dict[w2])
e = pairs_graph.add_edge(v1, v2)
edge_weights[e] = cur_weight
components_label = label_components(pairs_graph)
largest_label = label_largest_component(pairs_graph)
#print(components_label[0].a)
print(largest_label.a)
)
trace2= scatter_nodes([x,y],n,colors_graph)
data=Data([trace2])
fig = Figure(data=data, layout=layout)
#fig['layout'].update(annotations=make_annotations([x,y], n, colors_graph))
#offline.iplot(fig, filename='tst')
image.save_as(fig,args.emb_file+"-grafico.png",scale=3)
a = input('Pressione uma tecla para continuar: ')
if(a and int(a) == 0):
break
'''
g.vp.vertex_name[v]
g.vertex_index[v]
g.vertex(index)
'''
def main():
options = parse_arguments()
clusters_enabled = options["mapping_location"] is not None
if options["should_merge"] and not clusters_enabled:
raise "You need to provide a mapping to use merged view.`"
# Get the string containing the input matrix form a file/pipe
if options["matrix_location"] is not None:
with open(options["matrix_location"], 'r') as file:
matrix_string = file.read().strip().split("\n")
else:
matrix_string = sys.stdin
# Parse the input matrix string
height, width, matrix = parse_matrix(matrix_string, options["has_size"])
# Get the string containing the mapping if specified
if clusters_enabled:
with open(options["mapping_location"], 'r') as file:
mapping_string = file.read().strip()
mapping = parse_mapping(mapping_string, options["has_size"])
else:
mapping = None
if options["should_merge"]:
height, width, matrix, mapping = merge_clusters(matrix, mapping)
graph = Graph()
graph.add_vertex(height + width)
shape = graph.new_vertex_property("string")
color = graph.new_vertex_property("string")
index = graph.new_vertex_property("string")
for i in range(height):
v = graph.vertex(i)
shape[v] = "square"
color[v] = "red"
index[v] = str(i)
for i in range(width):
v = graph.vertex(height + i)
shape[v] = "circle"
if clusters_enabled:
color[v] = COLORS[mapping[i] % len(COLORS)]
else:
color[v] = COLORS[0]
index[v] = str(i)
for i in range(height):
for j in range(width):
if abs(matrix[i][j]) < EPSILON:
continue
graph.add_edge(graph.vertex(i), graph.vertex(height + j))
graph.set_directed(False)
if clusters_enabled:
groups = graph.new_vertex_property("int")
for i in range(width):
v = graph.vertex(height + i)
groups[v] = mapping[i]
position = sfdp_layout(graph, groups=groups)
else:
position = None
graph_draw(graph,
pos=position,
vertex_text=index,
vertex_shape=shape,
vertex_fill_color=color,
vertex_pen_width=1.2,
vertex_color="black",
edge_pen_width=3.4,
fit_view=True,
bg_color=(255, 255, 255, 1),
output=options["output_file"])
pos = int(spl_line[0])
neg = int(spl_line[1])
cur_weight = pos + coefficient * neg
w1 = spl_line[2].strip(' \n\uefef')
w2 = spl_line[3].strip(' \n\uefef')
if w1 in add_dict or w2 in add_dict:
continue
if w1 not in word_dict:
v1 = pairs_graph.add_vertex()
word_dict[w1] = pairs_graph.vertex_index[v1]
ver_names[v1] = w1
else:
v1 = pairs_graph.vertex(word_dict[w1])
if w2 not in word_dict:
v2 = pairs_graph.add_vertex()
word_dict[w2] = pairs_graph.vertex_index[v2]
ver_names[v2] = w2
else:
v2 = pairs_graph.vertex(word_dict[w2])
e = pairs_graph.add_edge(v1, v2)
edge_weights[e] = cur_weight
components_label = label_components(pairs_graph)
largest_label = label_largest_component(pairs_graph)
#print(components_label[0].a)
print(largest_label.a)
class SentenceGraph():
def __init__(self, sentence, directed=False, graph=None):
# Create a SentenceGraph from an existing graph tool graph
if graph is not None:
self.sentence_graph = graph
return
# Create a new SentenceGraph from scratch
self.sentence_graph = Graph(directed=directed)
# Graph properties
sentence_property = self.sentence_graph.new_graph_property("string", sentence)
self.sentence_graph.graph_properties[SENTENCE_KEY] = sentence_property
# Vertex properties
word_property = self.sentence_graph.new_vertex_property("string")
part_of_speech_property = self.sentence_graph.new_vertex_property("string")
vertex_color_property = self.sentence_graph.new_vertex_property("vector<double>")
self.sentence_graph.vertex_properties[WORD_KEY] = word_property
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY] = part_of_speech_property
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY] = vertex_color_property
# Edge properties
sentence_edge_property = self.sentence_graph.new_edge_property("string")
definition_edge_property = self.sentence_graph.new_edge_property("string")
parsed_dependencies_edge_property = self.sentence_graph.new_edge_property("string")
inter_sentence_edge_property = self.sentence_graph.new_edge_property("string")
edge_color_property = self.sentence_graph.new_edge_property("vector<double>")
dependency_edge_property = self.sentence_graph.new_edge_property("string")
self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY] = sentence_edge_property
self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY] = definition_edge_property
self.sentence_graph.edge_properties[PARSED_DEPENDENCIES_EDGE_KEY] = parsed_dependencies_edge_property
self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY] = inter_sentence_edge_property
self.sentence_graph.edge_properties[EDGE_COLOR_KEY] = edge_color_property
self.sentence_graph.edge_properties[PARSE_TREE_DEPENDENCY_VALUE_KEY] = dependency_edge_property
# Edge filter properties
definition_edge_filter_property = self.sentence_graph.new_edge_property("bool")
inter_sentence_edge_filter_property = self.sentence_graph.new_edge_property("bool")
parsed_dependencies_edge_filter_property = self.sentence_graph.new_edge_property("bool")
sentence_edge_filter_property = self.sentence_graph.new_edge_property("bool")
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY] = definition_edge_filter_property
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY] = inter_sentence_edge_filter_property
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY] = parsed_dependencies_edge_filter_property
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY] = sentence_edge_filter_property
def get_sentence(self):
return self.sentence_graph.graph_properties[SENTENCE_KEY]
def add_vertex(self, word, pos):
word_pos_tuple = (word, pos)
# Create vertex, set properties
word_vertex = self.sentence_graph.add_vertex()
self.sentence_graph.vertex_properties[WORD_KEY][word_vertex] = word
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][word_vertex] = pos
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY][word_vertex] = [0, 0, 1, 1]
return word_vertex
def set_vertex_color_from_word(self, word, pos, color=[1, 0, 0, 1]):
word_vertex = self.get_vertex(word, pos)
return self.set_vertex_color(word_vertex, color)
def set_vertex_color(self, vertex, color=[1, 0, 0, 1]):
self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY][vertex] = color
def set_vertices_color(self, vertices, color=[1, 0, 0, 1]):
for vertex in vertices:
self.set_vertex_color(vertex, color)
def add_sentence_edge_from_words(self, word1, pos1, word2, pos2):
return self.add_sentence_edge(self.get_vertex(word1, pos1), self.get_vertex(word2, pos2))
def add_sentence_edge(self, word_vertex1, word_vertex2):
sentence_edge = self.sentence_graph.add_edge(word_vertex1, word_vertex2, add_missing=False)
self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY][sentence_edge] = sentence_edge
# Green
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][sentence_edge] = [0.2, 1, 0.2, 1]
self._set_edge_to_zero_in_all_filters(sentence_edge)
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY][sentence_edge] = True
return sentence_edge
def add_sentence_edges(self, sentence_vertices):
for i in range(1, len(sentence_vertices)):
self.add_sentence_edge(sentence_vertices[i - 1], sentence_vertices[i])
def add_parsed_dependency_edge(self, word_vertex1, word_vertex2, dependency_relationship):
parsed_dependency_edge = self.sentence_graph.add_edge(word_vertex1, word_vertex2, add_missing=False)
self.sentence_graph.edge_properties[PARSED_DEPENDENCIES_EDGE_KEY][parsed_dependency_edge] = parsed_dependency_edge
self.sentence_graph.edge_properties[PARSE_TREE_DEPENDENCY_VALUE_KEY][parsed_dependency_edge] = dependency_relationship
# Blue
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][parsed_dependency_edge] = [0, 0, 1, 1]
self._set_edge_to_zero_in_all_filters(parsed_dependency_edge)
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY][parsed_dependency_edge] = True
return parsed_dependency_edge
def add_parsed_dependency_edge_from_words(self, word1, pos1, word2, pos2, dependency_relationship):
return self.add_parsed_dependency_edge(
self.get_vertex(word1, pos1),
self.get_vertex(word2, pos2),
dependency_relationship)
def add_definition_edge_from_words(self, word, pos, definition_word, definition_pos):
return self.add_definition_edge(
self.get_vertex(word, pos),
self.get_vertex(definition_word, definition_pos))
def _set_edge_to_zero_in_all_filters(self, edge):
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY][edge] = False
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY][edge] = False
def add_definition_edge(self, word_vertex, definition_word_vertex):
definition_edge = self.sentence_graph.add_edge(word_vertex, definition_word_vertex, add_missing=False)
self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY][definition_edge] = definition_edge
# Red
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][definition_edge] = [1, 0.1, 0.1, 1]
self._set_edge_to_zero_in_all_filters(definition_edge)
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY][definition_edge] = True
return definition_edge
def add_definition_edges(self, word_vertex, definition_word_vertices):
# Add edges from the word_vertex to all definition vertices and set
# the definition edge property on each edge
for definition_word_vertex in definition_word_vertices:
self.add_definition_edge(word_vertex, definition_word_vertex)
return self
def add_inter_sentence_edge(self, sentence1_word_vertex, sentence2_word_vertex):
inter_sentence_edge = self.sentence_graph.add_edge(sentence1_word_vertex, sentence2_word_vertex, add_missing=False)
self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY][inter_sentence_edge] = inter_sentence_edge
# Pink
self.sentence_graph.edge_properties[EDGE_COLOR_KEY][inter_sentence_edge] = [1, 0.05, 1, 1]
self._set_edge_to_zero_in_all_filters(inter_sentence_edge)
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY][inter_sentence_edge] = True
return inter_sentence_edge
def add_inter_sentence_edge_from_words(self, word1, pos1, word2, pos2):
return self.add_inter_sentence_edge(
self.get_vertex(word1, pos1),
self.get_vertex(word2, pos2))
def remove_vertex_by_word(self, word, pos):
self.remove_vertex(self.get_vertex(word, pos))
def remove_vertex(self, vertex):
word = self.sentence_graph.vertex_properties[WORD_KEY][vertex]
pos = self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
self.sentence_graph.remove_vertex(vertex)
def remove_edge(self, word1, pos1, word2, pos2):
self.sentence_graph.remove_edge(self.get_edge(word1, pos1, word2, pos2))
def contains(self, word, pos):
return self.get_vertex(word, pos) is not None
def get_vertex(self, word, pos):
for vertex in self.sentence_graph.vertices():
try:
vertex_word = self.sentence_graph.vertex_properties[WORD_KEY][vertex]
vertex_pos = self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
if vertex_word == word and vertex_pos == pos:
return vertex
except:
pass
return None
def get_word_pos_tuple(self, vertex):
return self.sentence_graph.vertex_properties[WORD_KEY][vertex],\
self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY][vertex]
def get_word_pos_tuple_by_index(self, index):
return self.get_word_pos_tuple(self.get_vertex_by_index(index))
def get_vertex_by_index(self, index):
return self.sentence_graph.vertex(index)
def get_vertices_iterator(self):
return self.sentence_graph.vertices()
def get_vertices(self):
return [x for x in self.sentence_graph.vertices()]
def get_vertex_out_neighbor_word_pos_tuples(self, vertex):
return [self.get_word_pos_tuple(neighbor_vertex)
for neighbor_vertex in self.get_vertex_out_neighbors(vertex)]
def get_vertex_in_neighbor_word_pos_tuples(self, vertex):
return [self.get_word_pos_tuple(neighbor_vertex)
for neighbor_vertex in self.get_vertex_in_neighbors(vertex)]
def get_vertex_out_neighbors(self, vertex):
return [neighbor_vertex for neighbor_vertex in vertex.out_neighbours()]
def get_vertex_in_neighbors(self, vertex):
return [neighbor_vertex for neighbor_vertex in vertex.in_neighbours()]
def get_word_pos_tuples(self):
return [self.get_word_pos_tuple(v) for v in self.sentence_graph.vertices()]
def get_num_vertices(self):
return self.sentence_graph.num_vertices()
def get_num_edges(self):
return self.sentence_graph.num_edges()
def get_edge(self, word1, pos1, word2, pos2):
vertex_1 = self.get_vertex(word1, pos1)
vertex_2 = self.get_vertex(word2, pos2)
return None\
if vertex_1 is None or vertex_2 is None\
else self.sentence_graph.edge(vertex_1, vertex_2)
def get_edges_iterator(self):
return self.sentence_graph.edges()
def get_edges(self):
return [x for x in self.sentence_graph.edges()]
def set_definition_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_DEFINITION_EDGE_KEY],
inverted=inverted)
def set_inter_sentence_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_INTER_SENTENCE_EDGE_KEY],
inverted=inverted)
def set_parsed_dependency_edge_filter(self, inverted=False):
self.sentence_edge.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_PARSED_DEPENDENCIES_EDGE_KEY],
inverted=inverted)
def set_sentence_edge_filter(self, inverted=False):
self.sentence_graph.set_edge_filter(
self.sentence_graph.edge_properties[FILTER_SENTENCE_EDGE_KEY],
inverted=inverted)
def clear_filters(self):
self.sentence_graph.clear_filters()
def get_definition_edges(self):
return filter(lambda x: x in self.get_definition_edge_properties(), self.get_edges())
def get_word_vertex_properties(self):
return self.sentence_graph.vertex_properties[WORD_KEY]
def get_pos_vertex_properties(self):
return self.sentence_graph.vertex_properties[PART_OF_SPEECH_KEY]
def get_color_vertex_properties(self):
return self.sentence_graph.vertex_properties[VERTEX_COLOR_KEY]
def get_sentence_edge_properties(self):
return self.sentence_graph.edge_properties[SENTENCE_EDGE_KEY]
def get_definition_edge_properties(self):
return self.sentence_graph.edge_properties[DEFINITION_EDGE_KEY]
def get_inter_sentence_edge_properties(self):
return self.sentence_graph.edge_properties[INTER_SENTENCE_EDGE_KEY]
def get_color_edge_properties(self):
return self.sentence_graph.edge_properties[EDGE_COLOR_KEY]
def get_vertex_index(self, vertex):
return self.sentence_graph.vertex_index[vertex]
def get_degree_properties(self, degree_type):
return self.sentence_graph.degree_property_map(degree_type)
def get_graph(self):
return self.sentence_graph
def copy(self):
return SentenceGraph(
sentence=self.sentence_graph.graph_properties[SENTENCE_KEY],
graph=self.sentence_graph.copy())
def steiner_tree_mst(g,
root,
infection_times,
source,
terminals,
closure_builder=build_closure,
strictly_smaller=True,
return_closure=False,
k=-1,
debug=False,
verbose=True):
gc, eweight, r2pred = closure_builder(g,
root,
terminals,
infection_times,
strictly_smaller=strictly_smaller,
k=k,
debug=debug,
verbose=verbose)
# get the minimum spanning arborescence
# graph_tool does not provide minimum_spanning_arborescence
if verbose:
print('getting mst')
gx = gt2nx(gc, root, terminals, edge_attrs={'weight': eweight})
try:
nx_tree = nx.minimum_spanning_arborescence(gx, 'weight')
except nx.exception.NetworkXException:
if debug:
print('fail to find mst')
if return_closure:
return None, gc, None
else:
return None
if verbose:
print('returning tree')
mst_tree = Graph(directed=True)
for _ in range(g.num_vertices()):
mst_tree.add_vertex()
for u, v in nx_tree.edges():
mst_tree.add_edge(u, v)
if verbose:
print('extract edges from original graph')
# extract the edges from the original graph
# sort observations by time
# and also topological order
topological_index = {}
for i, e in enumerate(bfs_iterator(mst_tree, source=root)):
topological_index[int(e.target())] = i
sorted_obs = sorted(set(terminals) - {root},
key=lambda o:
(infection_times[o], topological_index[o]))
tree_nodes = {root}
tree_edges = set()
# print('root', root)
for u in sorted_obs:
if u in tree_nodes:
if debug:
print('{} covered already'.format(u))
continue
# print(u)
v, u = map(int, next(mst_tree.vertex(u).in_edges())) # v is ancestor
tree_nodes.add(v)
late_nodes = [
n for n in terminals if infection_times[n] > infection_times[u]
]
vis = init_visitor(g, u)
# from child to any tree node, including v
cpbfs_search(g,
source=u,
terminals=list(tree_nodes),
forbidden_nodes=late_nodes,
visitor=vis,
count_threshold=1)
# dist, pred = shortest_distance(g, source=u, pred_map=True)
node_set = {v for v, d in vis.dist.items() if d > 0}
reachable_tree_nodes = node_set.intersection(tree_nodes)
ancestor = min(reachable_tree_nodes, key=vis.dist.__getitem__)
edges = extract_edges_from_pred(g, u, ancestor, vis.pred)
edges = {(j, i) for i, j in edges} # need to reverse it
if debug:
print('tree_nodes', tree_nodes)
print('connecting {} to {}'.format(v, u))
print('using ancestor {}'.format(ancestor))
print('adding edges {}'.format(edges))
tree_nodes |= {u for e in edges for u in e}
tree_edges |= edges
t = Graph(directed=True)
for _ in range(g.num_vertices()):
t.add_vertex()
for u, v in tree_edges:
t.add_edge(t.vertex(u), t.vertex(v))
tree_nodes = {u for e in tree_edges for u in e}
vfilt = t.new_vertex_property('bool')
vfilt.a = False
for v in tree_nodes:
vfilt[t.vertex(v)] = True
t.set_vertex_filter(vfilt)
if return_closure:
return t, gc, mst_tree
else:
return t
def build_region_closure(g,
root,
regions,
infection_times,
obs_nodes,
debug=False):
"""return a closure graph on the the components"""
regions = copy(regions)
root_region = {'nodes': {root}, 'head': root, 'head_time': -float('inf')}
regions[len(regions)] = root_region
gc = Graph(directed=True)
for _ in range(len(regions)):
gc.add_vertex()
# connect each region
gc_edges = []
original_edge_info = {}
for i, j in combinations(regions, 2):
# make group i the one with *later* head
if regions[i]['head_time'] < regions[j]['head_time']:
i, j = j, i
if debug:
print('i, j={}, {}'.format(i, j))
# only need to connect head i to one of the nodes in group j
# where nodes in j have time stamp < head i
# then an edge from region j to region i (because j is earlier)
head_i = regions[i]['head']
def get_pseudo_time(n):
if n == root:
return -float('inf')
else:
return infection_times[n]
targets = [
n for n in regions[j]['nodes']
if get_pseudo_time(n) < regions[i]['head_time']
]
if debug:
print('head_i: {}'.format(head_i))
print('targets: {}'.format(targets))
print('regions[j]["nodes"]: {}'.format(regions[j]['nodes']))
if len(targets) == 0:
continue
visitor = init_visitor(g, head_i)
forbidden_nodes = list(
set(regions[i]['nodes'])
| (set(regions[j]['nodes']) - set(targets)))
if debug:
print('forbidden_nodes: {}'.format(forbidden_nodes))
# NOTE: count_threshold = 1
cpbfs_search(g,
source=head_i,
terminals=targets,
forbidden_nodes=forbidden_nodes,
visitor=visitor,
count_threshold=1)
reachable_targets = [t for t in targets if visitor.dist[t] > 0]
if debug:
print('reachable_targets: {}'.format(reachable_targets))
if len(reachable_targets) == 0:
# cannot reach there
continue
source = min(reachable_targets, key=visitor.dist.__getitem__)
dist = visitor.dist[source]
assert dist > 0
gc_edges.append(((j, i, dist)))
original_edge_info[(j, i)] = {
'dist': dist,
'pred': visitor.pred,
'original_edge': (source, head_i)
}
for u, v, _ in gc_edges:
gc.add_edge(u, v)
eweight = gc.new_edge_property('int')
for u, v, c in gc_edges:
eweight[gc.edge(gc.vertex(u), gc.vertex(v))] = c
return gc, eweight, original_edge_info
def load_instance(filepath):
g = Graph(directed=False)
node_upgraded = g.new_vertex_property("bool")
node_cost = g.new_vertex_property("float")
edge_weight = g.new_edge_property("float")
edge_weight_lv2 = g.new_edge_property("float")
edge_weight_lv3 = g.new_edge_property("float")
edge_upgradeable_weights = g.new_edge_property("vector<float>")
graph_total_cost = g.new_graph_property("float")
graph_total_cost[g] = 0
with open(filepath, "r") as f:
first_line = f.readline()
tokens = first_line.split(" ")
assert len(tokens) == 2
n = int(tokens[0])
m = int(tokens[1])
g.add_vertex(n)
#print (n, m)
for _ in range(m):
line = f.readline()
tokens = line.split(" ")
assert len(tokens) == 5
v1 = int(tokens[0])
v2 = int(tokens[1])
e = g.add_edge(v1, v2)
w1 = float(tokens[2])
w2 = float(tokens[3])
w3 = float(tokens[4])
edge_weight[e] = w1
edge_weight_lv2[e] = w2
edge_weight_lv3[e] = w3
# identify how weights are for vertices
line = f.readline()
v_cost = [float(x) for x in line.split(" ") if x != " "]
if len(v_cost) > 1: # case where formatting is incorrect
for i in range(n):
v = g.vertex(i)
node_cost[v] = v_cost[i]
node_upgraded[i] = False
else:
v = g.vertex(0)
node_cost[v] = float(v_cost[0])
node_upgraded[v] = False
vertices = g.vertices()
vertices.next()
for v in vertices:
line = f.readline()
c = float(line)
node_cost[v] = c
node_upgraded[v] = False
g.vp.is_upgraded = node_upgraded
g.vp.cost = node_cost
g.ep.weight = edge_weight
g.ep.weight_2 = edge_weight_lv2
g.ep.weight_3 = edge_weight_lv3
for v in g.vertices():
graph_total_cost[g] += node_cost[v]
g.gp.total_cost = graph_total_cost
return g
class Network:
def __init__(self, nodes_info=None, links_info=None, file_name=None):
self.g = Graph()
if nodes_info and links_info:
self.nodes_info = nodes_info
self.links_info = links_info
self.g.vertex_properties["name"] = self.g.new_vertex_property(
'string')
self.g.vertex_properties["id"] = self.g.new_vertex_property(
'int32_t')
self.g.edge_properties["weight"] = self.g.new_edge_property(
'int32_t')
self.create_network()
self.g.vertex_properties["pagerank"] = pagerank(
self.g, weight=self.g.edge_properties["weight"])
self.g.vertex_properties[
"degree_centrality"] = self.degree_centrality()
elif file_name:
self.load_network(file_name)
def create_network(self):
# Add Nodes
for node in self.nodes_info:
self.add_n(node)
# Add Links
for link in self.links_info:
n_loser = 0
n_winner = 0
loser = link['loser']
winner = link['winner']
weight = link['rounds']
for team_id in self.g.vertex_properties.id:
if loser == team_id:
break
n_loser += 1
for team_id in self.g.vertex_properties.id:
if winner == team_id:
break
n_winner += 1
self.add_l(n_loser, n_winner, 16 / weight * 100)
def load_network(self, file_name):
new_file_name = '..' + sep + '..' + sep + 'network-graphs' + sep + file_name
self.g.load(new_file_name, fmt="gt")
def get_normalized_pagerank(self):
max_pgr = 0
for pgr in self.g.vertex_properties.pagerank:
if pgr > max_pgr:
max_pgr = pgr
return [
self.g.vertex_properties.pagerank[v] / max_pgr
for v in self.g.vertices()
]
def add_n(self, node_info):
n = self.g.add_vertex()
self.g.vertex_properties.id[n] = node_info['id']
self.g.vertex_properties.name[n] = node_info['Team_Name']
def add_l(self, loser, winner, weight):
n1 = self.g.vertex(loser)
n2 = self.g.vertex(winner)
l = self.g.add_edge(n1, n2)
self.g.edge_properties.weight[l] = weight
def draw(self, output_file, fmt):
graph_draw(self.g,
vertex_text=self.g.vertex_index,
output=output_file,
fmt=fmt)
def save_network(self, file_name):
try:
new_file_name = '..' + sep + '..' + sep + 'network-graphs' + sep + file_name
self.g.save(new_file_name, fmt="gt")
except:
return False
return True
def vp_pagerank(self):
return self.g.vertex_properties.pagerank
def vp_degree_cent(self):
return self.g.vertex_properties.degree_centrality
def vp_name(self):
return self.g.vertex_properties.name
def vp_id(self):
return self.g.vertex_properties.id
def ep_weight(self):
return self.g.edge_properties.weight
# Calcula as características básicas da rede
def get_basic_info(self):
info = {}
try:
n_vertices = self.g.num_vertices()
n_edges = self.g.num_edges()
density = n_edges / ((n_vertices * (n_vertices - 1)) / 2)
mean_degree = (2 * n_edges) / n_vertices
# Cálculo do coeficiente de clusterização "na mão", usando a média dos
# coeficientes locais calculados pela Graph Tools
local_cc = local_clustering(self.g)
clustering_coef = fsum(
[local_cc[x] for x in self.g.vertices() if local_cc[x] != 0.0])
clustering_coef /= n_vertices
info["Número de times"] = n_vertices
info["Número de confrontos"] = n_edges
info["Densidade"] = density
info["Grau médio"] = mean_degree
info["Coeficiente de Clusterização"] = clustering_coef
except:
info.clear()
return info
def degree_centrality(self):
degree_centrality = self.g.new_vertex_property('float')
for v in self.g.vertices():
degree_centrality[v] = v.in_degree() / (self.g.num_vertices() - 1)
return degree_centrality
# Calcula a distribuição de graus da rede
def degree_distribution(self):
degree_dist = {}
try:
for v in self.g.vertices():
if v.in_degree() not in degree_dist.keys():
degree_dist[v.in_degree()] = 1
else:
degree_dist[v.in_degree()] += 1
for k in degree_dist.keys():
degree_dist[k] /= self.g.num_vertices()
except:
degree_dist.clear()
return degree_dist
continue
pos = int(spl_line[0])
neg = int(spl_line[1])
cur_weight = pos + coefficient * neg
w1 = spl_line[2].strip(' \n\uefef')
w2 = spl_line[3].strip(' \n\uefef')
if w1 not in word_dict:
v1 = pairs_graph.add_vertex()
ver_id[v1] = pairs_graph.vertex_index[v1]
word_dict[w1] = ver_id[v1]
ver_names[v1] = w1
else:
v1 = pairs_graph.vertex(word_dict[w1])
if w2 not in word_dict:
v2 = pairs_graph.add_vertex()
ver_id[v2] = pairs_graph.vertex_index[v2]
word_dict[w2] = ver_id[v2]
ver_names[v2] = w2
else:
v2 = pairs_graph.vertex(word_dict[w2])
if cur_weight == 0:
continue
e = pairs_graph.add_edge(v1, v2)
edge_weights[e] = cur_weight
# adding properties
pairs_graph.vertex_properties["name"] = ver_names
class ResourceGraph(object):
v3_color = '#1C366B'
v2_color = '#1DACE8'
special_color = '#C4CFD0'
def __init__(self):
self.graph = Graph()
self.v_names = self.graph.new_vertex_property("string")
self.v_colors = self.graph.new_vertex_property("string")
self.e_names = self.graph.new_edge_property("string")
self.vertices = {}
self.edges = {}
def add_resource(self, resource_name, is_v3=True, is_special=False):
vertex = self.graph.add_vertex()
self.vertices[resource_name] = vertex
self.v_names[vertex] = resource_name
self.v_colors[vertex] = self.get_color(is_v3, is_special)
def get_color(self, is_v3, is_special):
if is_special:
return self.__class__.special_color
elif is_v3:
return self.__class__.v3_color
else:
return self.__class__.v2_color
def has_resource(self, resource_name):
return resource_name in self.vertices
def add_link(self, source_name, destination_name, name):
source = self.vertices[source_name]
destination = self.vertices[destination_name]
edge = self.graph.add_edge(source, destination)
edge_id = self.edge_id(source_name, destination_name, name)
self.edges[edge_id] = edge
self.e_names[edge] = name
def has_link(self, source_name, destination_name, name):
return self.edge_id(source_name, destination_name, name) in self.edges
def edge_id(self, source_name, destination_name, name):
return f'{name} -- {source_name} -- {destination_name}'
def draw(self):
graph_draw(
self.graph,
pos=radial_tree_layout(self.graph, self.graph.vertex(0)),
vertex_text=self.v_names,
vertex_fill_color=self.v_colors,
edge_text=self.e_names,
output_size=(2000, 1300),
fit_view=True,
vertex_font_size=10,
vertex_pen_width=1,
vertex_halo=False,
edge_pen_width=3,
)
def steiner_tree_mst(g, root, infection_times, source, terminals,
closure_builder=build_closure,
strictly_smaller=True,
return_closure=False,
k=-1,
debug=False,
verbose=True):
gc, eweight, r2pred = closure_builder(g, root, terminals,
infection_times,
strictly_smaller=strictly_smaller,
k=k,
debug=debug,
verbose=verbose)
# get the minimum spanning arborescence
# graph_tool does not provide minimum_spanning_arborescence
if verbose:
print('getting mst')
gx = gt2nx(gc, root, terminals, edge_attrs={'weight': eweight})
try:
nx_tree = nx.minimum_spanning_arborescence(gx, 'weight')
except nx.exception.NetworkXException:
if debug:
print('fail to find mst')
if return_closure:
return None, gc, None
else:
return None
if verbose:
print('returning tree')
mst_tree = Graph(directed=True)
for _ in range(g.num_vertices()):
mst_tree.add_vertex()
for u, v in nx_tree.edges():
mst_tree.add_edge(u, v)
if verbose:
print('extract edges from original graph')
# extract the edges from the original graph
# sort observations by time
# and also topological order
topological_index = {}
for i, e in enumerate(bfs_iterator(mst_tree, source=root)):
topological_index[int(e.target())] = i
sorted_obs = sorted(
set(terminals) - {root},
key=lambda o: (infection_times[o], topological_index[o]))
tree_nodes = {root}
tree_edges = set()
# print('root', root)
for u in sorted_obs:
if u in tree_nodes:
if debug:
print('{} covered already'.format(u))
continue
# print(u)
v, u = map(int, next(mst_tree.vertex(u).in_edges())) # v is ancestor
tree_nodes.add(v)
late_nodes = [n for n in terminals if infection_times[n] > infection_times[u]]
vis = init_visitor(g, u)
# from child to any tree node, including v
cpbfs_search(g, source=u, terminals=list(tree_nodes),
forbidden_nodes=late_nodes,
visitor=vis,
count_threshold=1)
# dist, pred = shortest_distance(g, source=u, pred_map=True)
node_set = {v for v, d in vis.dist.items() if d > 0}
reachable_tree_nodes = node_set.intersection(tree_nodes)
ancestor = min(reachable_tree_nodes, key=vis.dist.__getitem__)
edges = extract_edges_from_pred(g, u, ancestor, vis.pred)
edges = {(j, i) for i, j in edges} # need to reverse it
if debug:
print('tree_nodes', tree_nodes)
print('connecting {} to {}'.format(v, u))
print('using ancestor {}'.format(ancestor))
print('adding edges {}'.format(edges))
tree_nodes |= {u for e in edges for u in e}
tree_edges |= edges
t = Graph(directed=True)
for _ in range(g.num_vertices()):
t.add_vertex()
for u, v in tree_edges:
t.add_edge(t.vertex(u), t.vertex(v))
tree_nodes = {u for e in tree_edges for u in e}
vfilt = t.new_vertex_property('bool')
vfilt.a = False
for v in tree_nodes:
vfilt[t.vertex(v)] = True
t.set_vertex_filter(vfilt)
if return_closure:
return t, gc, mst_tree
else:
return t
continue
pos = int(spl_line[0])
neg = int(spl_line[1])
cur_weight = pos + coefficient * neg
w1 = spl_line[2].strip(' \n\uefef')
w2 = spl_line[3].strip(' \n\uefef')
if w1 not in word_dict:
v1 = pairs_graph.add_vertex()
ver_id[v1] = pairs_graph.vertex_index[v1]
word_dict[w1] = ver_id[v1]
ver_names[v1] = w1
else:
v1 = pairs_graph.vertex(word_dict[w1])
if w2 not in word_dict:
v2 = pairs_graph.add_vertex()
ver_id[v2] = pairs_graph.vertex_index[v2]
word_dict[w2] = ver_id[v2]
ver_names[v2] = w2
else:
v2 = pairs_graph.vertex(word_dict[w2])
if cur_weight == 0:
continue
e = pairs_graph.add_edge(v1, v2)
edge_weights[e] = cur_weight
# adding properties
pairs_graph.vertex_properties["name"] = ver_names
