def add_rectangles_by_path(self, path1, path2, start_offset):
path_len = 0
for p in path1:
path_len += p.len
# path_len -= start_offset
first_shift = start_offset
second_shift = 0
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
while first_len < path_len:
ed1 = path1[pos_first_path]
ed2 = path2[pos_second_path]
rectangle = Rectangle(ed1,ed2)
rectangle.add_diagonal(self.d, self.d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(self.d + first_shift - second_shift)
self.add_diagonal_and_conj(rect_diag)
print "ADD DIAGS", rect_diag
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
def add_rectangles_by_path(self, path1, path2, start_offset):
path_len = 0
for p in path1:
path_len += p.len
# path_len -= start_offset
first_shift = start_offset
second_shift = 0
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
while first_len < path_len:
ed1 = path1[pos_first_path]
ed2 = path2[pos_second_path]
rectangle = Rectangle(ed1, ed2)
rectangle.add_diagonal(self.d, self.d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(self.d + first_shift -
second_shift)
self.add_diagonal_and_conj(rect_diag)
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
def add_diagonal_and_conj(self, diag):
for old_diag in self.diagonals:
if diag.rectangle.e1 == old_diag.rectangle.e1 and diag.rectangle.e2 == old_diag.rectangle.e2:
if diag.D == old_diag.D:
return
rect = diag.rectangle
rect_conj = Rectangle(rect.e2.conj, rect.e1.conj)
conjugate(rect, rect_conj)
D = diag.D - diag.rectangle.e1.len + diag.rectangle.e2.len
pathset = diag.pathset.conj() if experimental.filter == experimental.Filter.pathsets else None
rect_conj.add_diagonal(self.d, D, pathset)
diag_conj = rect.conj.diagonals[D, pathset]
conjugate(diag, diag_conj)
return self.add_diagonal(diag)
def add_diagonal_and_conj(self, diag):
if diag in self.diagonals:
return
rect = diag.rectangle
rect_conj = Rectangle(rect.e2.conj, rect.e1.conj)
conjugate(rect, rect_conj)
D = diag.D - diag.rectangle.e1.len + diag.rectangle.e2.len
if experimental.filter == experimental.Filter.pathsets:
pathset = diag.pathset.conj()
else:
pathset = None
rect_conj.add_diagonal(self.d, D, pathset)
diag_conj = rect.conj.diagonals[D, pathset]
conjugate(diag, diag_conj)
return self.add_diagonal(diag)
def choose_best_path(self, paired_paths, rectangeles_set, diag1, diag2, d, added_paths):
best_support = 0
best_len = 10000
best_rectangles = []
best_diags = []
best_path = paired_paths[0]
best_not_supported = 0
for paired_path in paired_paths:
(path1, path2, path_len) = paired_path
if paired_path in added_paths:
continue
first_shift = diag1.offseta
second_shift = diag1.offsetb
path1.append(diag2.rectangle.e1)
path2.append(diag2.rectangle.e2)
rectangles = []
diags = []
not_supported = []
path_support = 0
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
make_less_N50 = False
while not make_less_N50 and first_len < path_len + diag2.offseta:
ed1 = path1[pos_first_path]
ed2 = path2[pos_second_path]
rectangle = Rectangle(ed1,ed2)
rectangle.add_diagonal(d, d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(d + first_shift - second_shift)
if (not (rect_diag.key1 == diag1.key1 and rect_diag.key2 == diag1.key2) and not(rect_diag.key1 == diag2.key1 and rect_diag.key2 == diag2.key2)):
can_use = [diag1.key1, diag1.key2, diag2.key1, diag2.key2]
if (rect_diag.key1 in self.vs and rect_diag.key1 not in can_use) or (rect_diag.key2 in self.vs and rect_diag.key2 not in can_use):
make_less_N50 = True
continue
diags.append(rect_diag)
rectangles.append(rectangle)
rectangeles_set.use_prd_diag(rect_diag)
#if rect_diag.prd_support < 0.00001 and (ed2.len > 10 and ed1.len > 10):
# make_less_N50 = True
# continue
path_support += rect_diag.prd_support
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
if rect_diag.prd_support < 0.000000001:
not_supported.append(ed2.len - second_shift)
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
if rect_diag.prd_support < 0.000000001:
not_supported.append(ed1.len - first_shift)
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
if not make_less_N50 and path_len > 1 and path_support / path_len < 1000 and path_support / path_len > best_support:
best_support = path_support
best_len = path_len
best_rectangles = rectangles
best_diags = diags
best_path = (path1, path2, path_len)
best_not_supported = not_supported
return (best_support,best_len, best_rectangles, best_diags, best_path)
def delete_missing_loops(self, DG_loops, K, L, threshold):
begs_related_to_loop = dict()
begin_loops = dict()
end_loops = dict()
for eeid1, (long_eid1, long_eid2, busheids, path, visited_vs) in DG_loops.items():
for k, be in self.es.items():
for diag in be.diagonals:
rect = diag.rectangle
eids = [rect.e1.eid, rect.e2.eid ]
if rect.e1.eid not in busheids or rect.e2.eid not in busheids:
continue
for eid in eids:
if eid not in busheids:
continue
if rect.e1.eid == long_eid1:
if rect.e2.eid == long_eid1:
begin_loops[long_eid1] = (diag, be)
if rect.e2.eid == long_eid2:
if rect.e1.eid == long_eid2:
end_loops[long_eid1] = (diag, be)
if eeid1 not in begs_related_to_loop:
begs_related_to_loop[eeid1] = set()
begs_related_to_loop[eeid1].add(be)
diag_to_add = set()
for eid, begs in begs_related_to_loop.items():
(long_eid1, long_eid2, busheids, path, visited_vs) = DG_loops[eid]
if len(begs) < 2:
continue
if eid not in begin_loops or eid not in end_loops:
print "not find begin_end"
continue
begin_diag = begin_loops[eid][0]
end_diag = end_loops[eid][0]
path.append(end_loops[eid][0].rectangle.e1)
first_shift = begin_diag.offseta
second_shift = begin_diag.offsetb
path_len = 0
for e in path:
path_len += e.len
rectangles = []
diags = []
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
while first_len < path_len and pos_second_path < len(path):
ed1 = path[pos_first_path]
ed2 = path[pos_second_path]
rectangle = Rectangle(ed1,ed2)
rectangle.add_diagonal(self.d, self.d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(self.d + first_shift - second_shift)
rectangles.append(rectangle)
diags.append(rect_diag)
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
for diag in diags:
diag_to_add.add(diag)
for bedge in begs:
self.__remove_bedge__(bedge)
self.__remove_bedge__(bedge.conj)
for diag in bedge.diagonals:
if diag.rectangle.e1.eid not in busheids or diag.rectangle.e2.eid not in busheids:
diag_to_add.add(diag)
if begin_diag in bedge.diagonals:
for diag in bedge.diagonals:
if diag == begin_diag:
break
diag_to_add.add(diag)
elif end_diag in bedge.diagonals:
bedge.diagonals.reverse()
for diag in bedge.diagonals:
if diag == end_diag:
break
diag_to_add.add(diag)
for diag in diag_to_add:
self.add_diagonal_and_conj(diag)
def delete_missing_loops(self, DG_loops, K, L, threshold):
if DG_loops == None:
return
begs_related_to_loop = defaultdict(set)
begin_loops = dict()
end_loops = dict()
for k, be in self.es.items():
for diag in be.diagonals:
for eeid1, (long_eid1, long_eid2, busheids, path, visited_vs,
all_paths) in DG_loops.items():
rect = diag.rectangle
if not set([rect.e1.eid, rect.e2.eid]) <= busheids:
continue
if rect.e1.eid == long_eid1 and rect.e2.eid == long_eid1:
begin_loops[long_eid1] = (diag, be)
if rect.e1.eid == long_eid2 and rect.e2.eid == long_eid2:
end_loops[long_eid1] = (diag, be)
begs_related_to_loop[eeid1].add(be)
diag_to_add = []
for eid, begs in begs_related_to_loop.items():
(long_eid1, long_eid2, busheids, path, visited_vs,
all_paths) = DG_loops[eid]
path = self.choose_best_path(all_paths, long_eid1, long_eid2, begs)
if len(begs) < 2:
continue
if eid not in begin_loops or eid not in end_loops:
continue
begin_diag = begin_loops[eid][0]
if begin_diag.rectangle.e1.len < 2 * self.d or len(
path) < 1 or path[0] != begin_diag.rectangle.e1 or path[
0].len < 2 * self.d:
self.logger.info("BAD CASE " + str(eid) + " " +
str(begin_diag.rectangle.e1.len) + " " +
str((long_eid1, long_eid2, busheids, path,
visited_vs)))
continue
end_diag = end_loops[eid][0]
path.append(end_loops[eid][0].rectangle.e1)
first_shift = begin_diag.offseta
second_shift = begin_diag.offsetb
path_len = reduce(lambda s, e: s + e.len, path, 0)
rectangles = []
diags = []
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
while first_len < path_len and pos_second_path < len(path):
ed1 = path[pos_first_path]
ed2 = path[pos_second_path]
rectangle = Rectangle(ed1, ed2)
rectangle.add_diagonal(self.d,
self.d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(self.d +
first_shift -
second_shift)
rectangles.append(rectangle)
diags.append(rect_diag)
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
diag_to_add.extend(diags)
for bedge in begs:
self.__remove_bedge_and_conj(bedge)
for diag in bedge.diagonals:
if diag.rectangle.e1.eid not in busheids or diag.rectangle.e2.eid not in busheids:
diag_to_add.append(diag)
if begin_diag in bedge.diagonals:
for diag in bedge.diagonals:
if diag == begin_diag:
break
diag_to_add.append(diag)
elif end_diag in bedge.diagonals:
bedge.diagonals.reverse()
for diag in bedge.diagonals:
if diag == end_diag:
break
diag_to_add.append(diag)
for diag in diag_to_add:
self.add_diagonal_and_conj(diag)
def delete_missing_loops(self, DG_loops, K, L, threshold):
if DG_loops == None:
return
begs_related_to_loop = defaultdict(set)
begin_loops = dict()
end_loops = dict()
for k, be in self.es.items():
for diag in be.diagonals:
for eeid1, (long_eid1, long_eid2, busheids, path, visited_vs, all_paths) in DG_loops.items():
rect = diag.rectangle
if not set([rect.e1.eid, rect.e2.eid]) <= busheids:
continue
if rect.e1.eid == long_eid1 and rect.e2.eid == long_eid1:
begin_loops[long_eid1] = (diag, be)
if rect.e1.eid == long_eid2 and rect.e2.eid == long_eid2:
end_loops[long_eid1] = (diag, be)
begs_related_to_loop[eeid1].add(be)
diag_to_add = []
for eid, begs in begs_related_to_loop.items():
(long_eid1, long_eid2, busheids, path, visited_vs, all_paths) = DG_loops[eid]
path = self.choose_best_path(all_paths, long_eid1, long_eid2, begs)
if len(begs) < 2:
continue
if eid not in begin_loops or eid not in end_loops:
continue
begin_diag = begin_loops[eid][0]
if begin_diag.rectangle.e1.len < 2*self.d or len(path) < 1 or path[0] != begin_diag.rectangle.e1 or path[0].len < 2 * self.d:
self.logger.info("BAD CASE " + str( eid)+ " " + str( begin_diag.rectangle.e1.len) + " " +str((long_eid1, long_eid2, busheids, path, visited_vs)))
continue
end_diag = end_loops[eid][0]
path.append(end_loops[eid][0].rectangle.e1)
first_shift = begin_diag.offseta
second_shift = begin_diag.offsetb
path_len = reduce(lambda s, e: s + e.len, path, 0)
rectangles = []
diags = []
pos_first_path = 0
pos_second_path = 0
first_len = first_shift
while first_len < path_len and pos_second_path < len(path):
ed1 = path[pos_first_path]
ed2 = path[pos_second_path]
rectangle = Rectangle(ed1, ed2)
rectangle.add_diagonal(self.d, self.d + first_shift - second_shift)
rect_diag = rectangle.get_closest_diagonal(self.d + first_shift - second_shift)
rectangles.append(rectangle)
diags.append(rect_diag)
if ed2.len - second_shift < ed1.len - first_shift:
pos_second_path += 1
first_shift += ed2.len - second_shift
first_len += ed2.len - second_shift
second_shift = 0
elif ed1.len - first_shift < ed2.len - second_shift:
pos_first_path += 1
first_len += ed1.len - first_shift
second_shift += ed1.len - first_shift
first_shift = 0
else:
first_len += ed1.len - first_shift
pos_second_path += 1
pos_first_path += 1
first_shift = 0
second_shift = 0
diag_to_add.extend(diags)
for bedge in begs:
self.__remove_bedge_and_conj(bedge)
for diag in bedge.diagonals:
if diag.rectangle.e1.eid not in busheids or diag.rectangle.e2.eid not in busheids:
diag_to_add.append(diag)
if begin_diag in bedge.diagonals:
for diag in bedge.diagonals:
if diag == begin_diag:
break
diag_to_add.append(diag)
elif end_diag in bedge.diagonals:
bedge.diagonals.reverse()
for diag in bedge.diagonals:
if diag == end_diag:
break
diag_to_add.append(diag)
for diag in diag_to_add:
self.add_diagonal_and_conj(diag)
