def print_components_sizes(distance, points):
"""
affichage des tailles triees de chaque composante
"""
segments = []
research_base = [point for point in points]
origine = Point([0.0, 0.0])
total = research_base.copy()
s = 0
enveloppe = []
while len(research_base) > 0:
current = research_base[0]
research_base.pop(0)
for point in research_base:
if current.distance_to(point) < distance:
s += 1
segments.append(Segment([current, point]))
enveloppe.append(s)
print(enveloppe)
tycat(origine, total, segments)
def naif(filename):
"""
Fonction résolvant le problème de façon intuitive
"""
coupe = 0
intersections = []
adjuster, segments = load_segments(filename)
for i, seg_i in enumerate(segments):
for seg_j in segments[i:]:
inters = seg_i.intersection_with(seg_j)
if inters is not None:
inters = adjuster.hash_point(inters)
if inters not in seg_i.endpoints or inters not in seg_j.endpoints:
if inters not in intersections:
intersections.append(inters)
coupe += 1
print("le nombre d'intersections est : ", len(intersections))
print("le nombre de coupes est :", coupe)
tycat(segments, intersections)
return intersections
def main():
"""
petit exemple sur l'utilisation de tycat
"""
print("lancez moi dans terminology")
print("tycat permet d'afficher des points, des segments, des polygones")
print("chaque argument doit etre un iterable sur des points \
et/ou segments et/ou polygones (ou juste un point/segment/polygone)")
print("chaque argument est affiche d'une couleur differente")
# un point
origine = Point([0.0, 0.0])
# un vecteur de points
cercle = [Point([cos(c*pi/10), sin(c*pi/10)]) for c in range(20)]
# un iterateur sur des segments (crees a la volee)
segments = (
Segment([p1, p2])
for p1, p2 in zip(cercle, islice(cycle(cercle), 1, None))
)
# un carre
carre = Polygon.square(-1, -1, 2)
tycat(origine, cercle, segments, carre)
def main():
"""
tycat example
"""
points = [[Point([random(), random()]) for _ in range(5)] for _ in range(2)]
segments = [[Segment(endpoints) for endpoints in combinations(p, r=2)] for p in points]
print("tycat(points, segments)")
tycat(points, segments)
print("tycat(zip(iter(points), iter(segments)))")
tycat(zip(iter(points), iter(segments)))
print("tycat(*zip(iter(points), iter(segments)))")
tycat(*zip(iter(points), iter(segments)))
intersections = filter(None, (c[0].intersection_with(c[1]) for c in product(*segments)))
print("intersections entre rouge et vert")
tycat(segments[0], segments[1], intersections)
def print_components_sizes(distance, points):
"""
affichage des tailles triees de chaque composante
"""
SortedX = sorted([point for point in points], key = abscisse)
result = prochesX(SortedX, distance)
dernier_pointX_1 = result[len(result)-1]
dernier_indice = SortedX.index(dernier_pointX_1)
origine = Point([0.0, 0.0])
segment_1 = Segment([Point([dernier_pointX_1.x, 0]), Point([dernier_pointX_1.x, 1])])
SortedY = sorted([point for point in result], key = ordonnee)
result_bis = prochesY(SortedY, distance)
dernier_pointXbis_1 = result_bis[len(result_bis)-1]
dernier_indice_bis = SortedX.index(dernier_pointXbis_1)
segment_2 = Segment([Point([0, dernier_pointXbis_1.y]), Point([1, dernier_pointXbis_1.y])])
tycat(origine, points, (segment_1, segment_2))
"""
affichage des tailles triees de chaque composante
"""
segments = []
research_base = [point for point in points]
origine = Point([0.0, 0.0])
total = research_base.copy()
s = 0
enveloppe = []
while len(research_base) > 0:
current = research_base[0]
research_base.pop(0)
for point in research_base:
if current.distance_to(point) < distance:
s += 1
segments.append(Segment([current, point]))
enveloppe.append(s)
tycat(origine, total, segments)
def display(filename):
"""
load segment file, get back connexity, get even degrees, display eulerian path.
"""
segments = load_segments(filename)
g = Graph(segments)
tycat(g)
print("{}: nous avons {} segments".format(filename, len(segments)))
t1 = time.time()
g.reconnect(True)
t2 = time.time()
tps = t2 - t1
print("Temps reconnect hash:" + str(tps))
t1 = time.time()
g.even_degrees(True)
t2 = time.time()
tps = t2 - t1
print("Temps degré pair hash:" + str(tps))
g = Graph(segments)
t1 = time.time()
g.reconnect(False)
t2 = time.time()
tps = t2 - t1
print("Temps reconnect quad:" + str(tps))
t1 = time.time()
g.even_degrees(False)
t2 = time.time()
tps = t2 - t1
print("Temps degré pair quad:" + str(tps))
t1 = time.time()
g.eulerian_cycle()
t2 = time.time()
tps = t2 - t1
print("Temps cycle eulérien:" + str(tps))
def bentley_ottmann(filename, nodisp=False, noinfo=False):
"""
Fonction principale de notre projet
"""
global COUPE
COUPE = 0
y_cour = None
adjuster, segments = load_segments(filename)
actifs = SortedList()
evenements = [
] #liste de nos evenements, valeurs des y, que lon transformera en Tas ensuite
pt_inter = {
} #dictionnaire que lon retournera a la fin, associant les segments interseptés
index = 0
cache_inters = {} #cache qui nous dira si on a deja compare 2 seg
intersections = [] #liste contenant tous nos points dintersections
for seg in segments:
#initialisation de nos evenements
(x_0, y_0) = seg.endpoints[0].coordinates
(x_1, y_1) = seg.endpoints[1].coordinates
Segment.y_cour = [x_0, y_0]
if y_0 < y_1: #Segments croissant suivant les y
evenements.append([y_0, -x_0, seg, 'D'])
evenements.append([y_1, -x_1, seg, 'F'])
elif y_0 > y_1: #Segments decroissant suivant les y:
evenements.append([y_0, -x_0, seg, 'F'])
evenements.append([y_1, -x_1, seg, 'D'])
else: #Cas d'un segment horizontal
evenements.append([y_1, -min(x_0, x_1), seg, max(x_0, x_1)])
pt_inter[seg] = [] #Initialisation du dictionnaire
cache_inters[seg] = []
heapify(
evenements
) #Tas des evenement,3 types, 'D' 'F' 'I': Debut, fin, intersection
#trié en fonction des y croissant, puis des x décroissants.
def indice(seg):
"""
Retourne l'indice de seg dans la liste actifs, None si le segment n'est
pas présent. Cette fonction auxiliaire est implémentée suite aux
problèmes majeurs rencontrés avec la méthode index de la classe
SortedList
"""
for i, elmt in enumerate(actifs):
if seg is elmt:
return i
def intersection(seg, seg_2):
"""
Fonction qui va légitimer et gérer l'intersection entre 2 segments
donnés.
"""
global COUPE
if seg_2 not in cache_inters[seg]: #On ne compare pas deux segments
#déja comparés
intersection = seg.intersection_with(seg_2)
cache_inters[seg].append(seg_2)
cache_inters[seg_2].append(seg)
if intersection is not None:
intersection = adjuster.hash_point(intersection) #Ajustement
if intersection not in seg.endpoints or intersection not in seg_2.endpoints:
#Le point nest pas lextrémitié des deux segments
pt_inter[seg].append(seg_2)
pt_inter[seg_2].append(seg)
heappush(evenements, [
intersection.coordinates[1],
-intersection.coordinates[0], seg, 'I', seg_2
])
#L'ordre dans le tuple est important: il permet de savoir
#qui est à gauche ou à droite
if intersection not in intersections:
intersections.append(intersection)
COUPE += 1
return
while evenements: #Boucle traitant tous les évènements tant que notre tas
#n'est pas vide.
y_cour = heappop(evenements)
if y_cour[3] == 'D': #evenement de debut de segment
Segment.y_cour = [-y_cour[1], y_cour[0]]
actifs = SortedList(actifs) #Mise à jour de actifs
seg = y_cour[2]
actifs.add(seg) #Ajout du nouveau segment aux actifs
if len(actifs
) > 1: #Si un seul segment dans actifs: on ne fait rien
try:
index = actifs.index(seg)
except ValueError:
index = indice(seg)
if index != len(actifs) - 1:
seg_2 = actifs[index + 1]
intersection(seg, seg_2)
if index != 0:
seg_2 = actifs[index - 1]
intersection(seg_2, seg)
elif y_cour[3] == 'F': #evenement de fin de segment
Segment.y_cour = [-y_cour[1], y_cour[0]]
actifs = SortedList(actifs) #Mise à jour de actifs
seg = y_cour[2]
try:
index = actifs.index(seg)
except ValueError:
index = indice(seg)
actifs.pop(index)
actifs = SortedList(actifs) #Mise à jour de actifs
if len(actifs) > 1:
if 0 < index < len(actifs): #On n'enleve pas le seg le plus à
#droite/gauche
seg = actifs[index]
seg_2 = actifs[index - 1]
intersection(seg, seg_2)
elif y_cour[3] == 'I': #evenement de point d'intersection
seg, seg_2 = y_cour[2], y_cour[4]
try:
actifs.remove(seg)
except ValueError:
index = indice(seg)
if index is not None: #Renvoie parfois une erreur:
#"segment not in actifs"
del actifs[index]
try:
actifs.remove(seg_2)
except ValueError:
index_2 = indice(seg_2)
if index_2 is not None:
del actifs[index_2]
Segment.y_cour = [-y_cour[1], y_cour[0] + 0.00000000001]
#Cf. convention: A une intersection, on se situe
#au dessus de l'intersection
actifs = SortedList(actifs) #Mise à jour de actifs
actifs.add(seg) #Une fois changés de place l'intersection passée,
#on remet nos deux segments dans actifs
actifs.add(seg_2)
try:
index = actifs.index(seg) #Indice du seg a droite une fois
#l'intersection faite
except ValueError:
index = indice(seg)
if len(actifs
) > 2: #On teste les nouvelles intersections possibles
if index < len(
actifs) - 1: #Cas de l'extrémité droite de actifs
seg_2 = actifs[index + 1]
intersection(seg, seg_2)
if index - 1 != 0: #Cas de l'extrémité gauche
seg_2 = actifs[index - 2]
intersection(seg_2, y_cour[4])
else: #Cas dun segment horizontal
seg_h = y_cour[2]
for seg in actifs:
inter = seg_h.intersection_with(seg)
if inter:
inter = adjuster.hash_point(inter)
if inter not in seg_h.endpoints or inter not in seg.endpoints:
#Le point n'est pas l'extrémité ds deux segments
pt_inter[seg_h].append(seg)
pt_inter[seg].append(seg_h)
if inter not in intersections:
intersections.append(inter)
COUPE += 1
if nodisp and noinfo:
return pt_inter, intersections
if noinfo:
tycat(segments, intersections)
return pt_inter, intersections
if nodisp:
print(
"Le nombre d'intersections (= le nombre de points differents) est : ",
len(intersections))
print("Le nombre de coupes est : ", COUPE)
return pt_inter, intersections
print(
"le nombre d'intersections (= le nombre de points differents) est : ",
len(intersections))
print("le nombre de coupes est : ", COUPE)
def test(filename):
"""
run bentley ottmann
"""
adjuster, segments = load_segments(filename)
#segments = sorted(segments, key=lambda x: min(x.endpoints[0].coordinates[1],
# x.endpoints[0].coordinates[1]))
events = SortedList()
for s in segments:
events.add((min(s.endpoints), "in", s))
events.add((max(s.endpoints), "out", s))
sweep = SweepLines()
result = []
if DEBUG:
print("Events (init):", events)
print("\n========\n LOOP \n========\n\n ")
while True:
try:
current, event_type, segment = events.pop(0)
Segment.point = current
if DEBUG:
print("Current:", current, event_type, segment)
if DEBUG:
print("Events:", events)
if DEBUG:
print("SL:", len(sweep), sweep)
tmp_sweep = SweepLines()
for node in sweep:
tmp_sweep.put(node.value)
sweep = tmp_sweep
if DEBUG:
print("SL:", len(sweep), sweep)
if event_type == "in":
node = sweep.put(segment)
left = node.predecessor()
if left:
left = left.value
intrsctn = segment.intersection_with(left)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[
1] and intrsctn.coordinates[
0] != current.coordinates[0]:
events.add((intrsctn, "x", (left, segment)))
right = node.successor()
if right:
right = right.value
intrsctn = segment.intersection_with(right)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[
1] and intrsctn.coordinates[
0] != current.coordinates[0]:
events.add((intrsctn, "x", (segment, right)))
elif event_type == "out":
node = sweep.search(segment)
left = node.predecessor()
right = node.successor()
if left and right:
left = left.value
right = right.value
intrsctn = left.intersection_with(right)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[
1] and intrsctn.coordinates[
0] != current.coordinates[0]:
events.add((intrsctn, "x", (left, right)))
sweep.delete(segment)
else: #event_type == "x"
result.append(current)
u = sweep.search(segment[0])
right = u.successor()
if right:
intrsctn = u.value.intersection_with(right.value)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[
1] and intrsctn.coordinates[
0] != current.coordinates[0]:
events.add((intrsctn, "x", (u.value, right.value)))
v = sweep.search(segment[1])
left = v.predecessor()
if left:
intrsctn = v.value.intersection_with(left.value)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[
1] and intrsctn.coordinates[
0] != current.coordinates[0]:
events.add((intrsctn, "x", (left.value, v.value)))
if DEBUG:
print("Events:", events)
if DEBUG:
print("SL:", len(sweep), sweep)
#tycat(segments, result, current)
#input("Press [ENTER] to continue...\n")
except IndexError:
break
print("\n\n=========\n THE END\n=========")
if DEBUG:
print("Events:", events)
print("SL:", sweep)
print("IL:", result)
tycat(segments, result)
def print_polygons(polygons):
print("we have", len(polygons), "polygons")
tycat(*(poly.segments() for poly in polygons))
def display(filename):
"""
load segment file, get back connexity, get even degrees, display eulerian path.
"""
segments = load_segments(filename)
graphe1 = Graph(segments)
graphe2 = Graph(segments)
tycat(graphe1)
t1 = time.time()
graphe1.reconnect(False)
t2 = time.time()
t1h = time.time()
graphe2.reconnect(True)
t2h = time.time()
tycat(graphe1)
tycat(graphe2)
print("Temps mis pour reconnecter le graphe : ")
print("Sans hash : {}".format(t2 - t1))
print("Avec hash : {}".format(t2h - t1h))
t1 = time.time()
graphe1.even_degrees(False)
t2 = time.time()
t1h = time.time()
graphe2.even_degrees(True)
t2h = time.time()
tycat(graphe1)
tycat(graphe2)
print("Temps mis par even_degrees: ")
print("Sans hash : {}".format(t2 - t1))
print("Avec hash : {}".format(t2h - t1h))
t1 = time.time()
cycle1 = graphe1.eulerian_cycle()
t2 = time.time()
t1h = time.time()
cycle2 = graphe2.eulerian_cycle()
t2h = time.time()
tycat(cycle1)
tycat(cycle2)
print("Temps mis pour trouver un cycle eulérien : ")
print("Sur graphe1 : {}".format(t2 - t1))
print("Sur graphe2 : {}".format(t2h - t1h))
print("Nombres de sommets : {}".format(len(graphe2.vertices.keys())))
print("Nombres d'arêtes {}".format(len(segments)))
def test(filepath, bool_save, bool_tycat, bool_log):
"""
- runs bentley ottmann and naive algorithm
- prints the number of intersections and crossings within segments found with b_o
- prints the runtime for both algorithm
- if bool_save = True, saves the figure with all the crossings found with b_o
- if bool_tycat = True, displays the figure with all the crossings found with b_o
- if bool_log = True, save statistics in a log.csv file
"""
adjuster, segments = load_segments(filepath)
name_of_figure = re.match(r"(.*/|.*)(.+).bo", filepath).group(2)
# Launching Bentley-Ottmann
print("\n Running Bentley Ottmann on {} ...\n".format(name_of_figure))
results_bo, graph_bo = bentley_ottmann(adjuster, segments)
# Printing some statistics
unique_intersections = list(set().union(*results_bo.values()))
number_of_unique_intersections = len(unique_intersections)
number_of_crossings = sum([len(list) for list in results_bo.values()])
if graph_bo[0][-1] >= 1199:
runtime_bo = ">20m"
else:
runtime_bo = "{}m {}s".format(round(graph_bo[0][-1]//60), graph_bo[0][-1]%60)
print(" Unique intersections : {}".format(number_of_unique_intersections))
print(" Crossings within segments : {}".format(number_of_crossings))
print(" Runtime for Bentley Ottmann : {}\n".format(runtime_bo))
# Launching naive algorithm
print("\n Running naive algorithm on {} ...\n".format(name_of_figure))
results_na, graph_na = naive(adjuster, segments)
if graph_na[0][-1] >= 1199:
runtime_na = ">20m"
else:
runtime_na = "{}m {}s".format(round(graph_na[0][-1]//60), graph_na[0][-1]%60)
print(" Runtime for naive algorithm : {}\n".format(runtime_na))
# Ploting the results to png file
directory = "./outputs"
if not exists(directory):
makedirs(directory)
plt.xlabel('Time elapsed (s)')
plt.ylabel('Intersections processed')
plt.title('{}.png'.format(name_of_figure))
plt.plot(graph_bo[0], graph_bo[1], label='Bentley Ottmann')
plt.plot(graph_na[0], graph_na[1], label='Naive algorithm')
plt.legend()
plt.savefig('./outputs/{}.png'.format(name_of_figure))
plt.clf()
# If Bentley-Ottmann didn't end before 20m, we save the results from the naive algorithm
if runtime_bo == ">20m":
unique_intersections = list(set().union(*results_na.values()))
number_of_unique_intersections = len(unique_intersections)
number_of_crossings = sum([len(list) for list in results_na.values()])
# Printing and/or saving the figure with all the found crossings
if bool_save:
save_svg([segments, unique_intersections], filepath)
if bool_tycat:
tycat(segments, unique_intersections)
#Saving the statistics in a csv file
if bool_log:
if not isfile("./log.csv"):
with open("log.csv", "w") as file:
file.write("File; Unique intersections;Crossings;Runtime with Bentley-Ottmann;Runtime with naive algorithm\n")
with open("log.csv", "a") as file:
file.write("{}; {}; {}; {}; {}\n".format(name_of_figure, number_of_unique_intersections, number_of_crossings, runtime_bo, runtime_na))
def draw_step(self, living, current):
"""
draw the living segments and the current_point on top of the normal draw
"""
tycat(self.segments(), self.intersection_points(), living, current)
def draw(self):
"""
draws the segment and the intersection points
"""
tycat(self.segments(), self.intersection_points())
def test(filename):
"""
run bentley ottmann
"""
adjuster, segments = load_segments(filename)
#segments = sorted(segments, key=lambda x: min(x.endpoints[0].coordinates[1],
# x.endpoints[0].coordinates[1]))
events = SortedList()
for s in segments:
events.add((min(s.endpoints), "in", s))
events.add((max(s.endpoints), "out", s))
sweep = SortedList()
result = []
if DEBUG:
print("Events (init):", events)
print("\n========\n LOOP \n========\n\n ")
while True:
try:
current, event_type, segment = events.pop(0)
Segment.point = current
if DEBUG:
print("Current:", current, event_type, segment)
if DEBUG:
print("Events:", events)
if DEBUG:
print("SL:", len(sweep), sweep)
tmp_sweep = SortedList()
for line in sweep:
tmp_sweep.add(line)
sweep = tmp_sweep
if DEBUG:
print("SL:", len(sweep), sweep)
if event_type == "in":
sweep.add(segment)
i = sweep.index(segment)
left = i-1
if left >= 0:
left = sweep[left]
intrsctn = segment.intersection_with(left)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[1] and intrsctn.coordinates[0] != current.coordinates[0]:
events.add((intrsctn, "x", (left, segment)))
right = i+1
if right < len(sweep):
right = sweep[right]
intrsctn = segment.intersection_with(right)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[1] and intrsctn.coordinates[0] != current.coordinates[0]:
events.add((intrsctn, "x", (segment, right)))
elif event_type == "out":
i = sweep.index(segment)
left = i-1
right = i+1
if left >= 0 and right < len(sweep):
left = sweep[left]
right = sweep[right]
intrsctn = left.intersection_with(right)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[1] and intrsctn.coordinates[0] != current.coordinates[0]:
events.add((intrsctn, "x", (left, right)))
sweep.remove(segment)
else: #event_type == "x"
result.append(current)
u = sweep.index(segment[0])
right = u+1
if right < len(sweep):
u = sweep[u]
right = sweep[right]
intrsctn = u.intersection_with(right)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[1] and intrsctn.coordinates[0] != current.coordinates[0]:
events.add((intrsctn, "x", (u, right)))
v = sweep.index(segment[1])
left = v-1
if left >= 0:
v = sweep[v]
left = sweep[left]
intrsctn = v.intersection_with(left)
if intrsctn is not None:
intrsctn = adjuster.hash_point(intrsctn)
if intrsctn.coordinates[1] <= current.coordinates[1] and intrsctn.coordinates[0] != current.coordinates[0]:
events.add((intrsctn, "x", (left, v)))
if DEBUG:
print("Events:", events)
if DEBUG:
print("SL:", len(sweep), sweep)
#tycat(segments, result, current)
#input("Press [ENTER] to continue...\n")
except IndexError as e:
print(e)
break
print("\n\n=========\n THE END\n=========")
if DEBUG:
print("Events:", events)
print("SL:", sweep)
print("IL:", result)
tycat(segments, result)
def test(filename):
"""
run bentley ottmann
"""
#debug = True --> debug version, debug = False --> no debug option version
debug = False
#print the event_queue_list before the suppression
debug1 = False
#print details when the event is an intersection
debug2 = False
#print the event_queue in the beginning
debug3 = False
#print the intersections
debug4 = False
#print details when the event is an ending segment point
debug5 = False
adjuster, segments = load_segments(filename)
tycat(segments)
event_queue_list = Event_Queue(None, None)
intersections = []
for seg in segments:
event_queue_list.add_segment(seg)
if debug3:
print("{}".format(seg))
print("")
event_queue_list.parcourir()
print("")
print("")
if debug3:
event_queue_list.parcourir()
event_queue = event_queue_list.tete
sweep_line = Sweep_Line(None, None)
current_event = event_queue.point_list
iteration = 0
while event_queue is not None:
if debug:
print("je suis passé par le début")
while current_event is not None:
#case where event is the beginnig of a segment
if (current_event.nature == -1):
if debug:
print("the algo take the way of a first segment point")
seg = sweep_line.insert(current_event.segment1,
event_queue.value)
seg_above = seg.next
seg_below = seg.precedent
seg = seg.segment
if seg_above != None:
seg_above = seg_above.segment
intersec = seg.intersection_with(seg_above)
if intersec is not None:
if intersec == seg_above.endpoints[
0] or intersec == seg_above.endpoints[
1] or intersec == seg.endpoints[
0] or intersec == seg.endpoints[1]:
intersec = None
if intersec is not None:
event_queue_list.insert(intersec, 0, seg, seg_above)
if seg_below != None:
seg_below = seg_below.segment
intersec = seg.intersection_with(seg_below)
if intersec is not None:
if intersec == seg_below.endpoints[
0] or intersec == seg_below.endpoints[
1] or intersec == seg.endpoints[
0] or intersec == seg.endpoints[1]:
intersec = None
if intersec is not None:
event_queue_list.insert(intersec, 0, seg_below, seg)
#case when event is the end of a segment
elif (current_event.nature == 1):
if debug:
print("the algo take the way of an ending segment point")
seg = sweep_line.tete
while seg.segment != current_event.segment1:
seg = seg.next
seg_above = seg.next
seg_below = seg.precedent
if debug5:
print(seg_below == None)
print(seg_above == None)
seg = seg.segment
if seg_below is None and seg_above is None:
sweep_line.tete = None
sweep_line.queue = None
elif seg_below is None:
seg_above.precedent = None
sweep_line.tete = seg_above
elif seg_above is None:
seg_below.next = None
sweep_line.queue = seg_below
else:
seg_below.next = seg_above
seg_above.precedent = seg_below
seg_below = seg_below.segment
seg_above = seg_above.segment
intersec = seg_below.intersection_with(seg_above)
if intersec is not None:
if intersec == seg_below.endpoints[
0] or intersec == seg_below.endpoints[
1] or intersec == seg_above.endpoints[
0] or intersec == seg_above.endpoints[
1]:
intersec = None
if intersec is not None:
if not event_queue_list.possess(intersec):
event_queue_list.insert(intersec, 0, seg_below,
seg_above)
#case when event is an intersection
else:
if debug:
print("the algo take the way of an intersection point")
intersections.append(
Point([event_queue.value, current_event.ordinate]))
if debug2:
print(current_event.ordinate)
print(current_event.segment1)
print(current_event.segment2)
seg_above = sweep_line.tete
while seg_above.segment != current_event.segment2:
if debug2:
print(seg_above.segment)
seg_above = seg_above.next
if seg_above is None:
break
seg_below = sweep_line.tete
if debug2:
print(seg_below.segment)
while seg_below.segment != current_event.segment1:
if debug2:
print(seg_below.segment)
seg_below = seg_below.next
if seg_below is None:
break
if seg_below is None:
if debug2:
print("seg_below is None")
elif seg_above is None:
if debug2:
print("seg_above is None")
else:
if debug2:
print(seg_below.segment)
print(seg_above.segment)
seg_below.segment, seg_above.segment = seg_above.segment, seg_below.segment
seg_above2 = seg_above.next
seg_below2 = seg_below.precedent
if debug2:
print(seg_below.segment)
print(seg_above.segment)
if seg_below2 is not None:
print(seg_below2.segment)
else:
print("SEG_BELOW2 IS NONE")
if seg_above2 is not None:
print(seg_above2.segment)
else:
print("SEG_ABOVE2 IS NONE")
if seg_above2 is not None:
intersec = seg_above.segment.intersection_with(
seg_above2.segment)
if intersec is not None:
if intersec == seg_above.segment.endpoints[
0] or intersec == seg_above.segment.endpoints[
1] or intersec == seg_above2.segment.endpoints[
0] or intersec == seg_above2.segment.endpoints[
1]:
intersec = None
if intersec is not None:
if not event_queue_list.possess(intersec):
event_queue_list.insert(
intersec, 0, seg_above.segment,
seg_above2.segment)
if seg_below2 is not None:
intersec = seg_below.segment.intersection_with(
seg_below2.segment)
if intersec is not None:
if intersec == seg_below.segment.endpoints[
0] or intersec == seg_below.segment.endpoints[
1] or intersec == seg_below2.segment.endpoints[
0] or intersec == seg_below2.segment.endpoints[
1]:
intersec = None
if intersec is not None:
if not event_queue_list.possess(intersec):
event_queue_list.insert(
intersec, 0, seg_below2.segment,
seg_below.segment)
#exit the current point_list
if debug1:
print("BEFORE THE SUPPRESSION")
print(event_queue.value)
event_queue_list.parcourir()
if (current_event.next is None) and (current_event.precedent is
None):
event_queue.point_list = None
event_queue = event_queue.next
if event_queue is not None:
current_event = event_queue.point_list
else:
current_event = None
elif current_event.next is None:
current_event.precedent.next = None
current_event = current_event.precedent
elif current_event.precedent is None:
current_event.next.precedent = None
current_event = current_event.next
event_queue.point_list = current_event
else:
current_event.precedent.next = current_event.next
current_event.next.precedent = current_event.precedent
current_event = current_event.next
iteration += 1
if debug:
#some prints allows the text color to change in the terminal, it's easier to debug
#print ('\033[1;32m\033[1;m')
print("IT IS ITERATION NUMBER '{}'".format(iteration))
#print ('\033[1;37m\033[1;m')
#print ('\033[1;35m\033[1;m')
event_queue_list.parcourir()
#print ('\033[1;37m\033[1;m')
sweep_line.parcourir()
print("")
if debug4:
parcourir_liste(intersections)
print("")
if debug:
print(iteration)
tycat(segments, intersections)
print(
'le nombre d intersections (= le nombre de points differents) est "{}"'
.format(len(intersections)))
def print_components_sizes(distance, points):
origine = Point([0.0, 0.0])
SortedX = sorted([point for point in points], key = abscisse)
print("nombre de point est :", len(SortedX))
# print(SortedX)
result = prochesX(SortedX, distance)
print("nombre de points dans result est :", len(result))
n = len(result)
dernier_pointX_1 = result[-1]
segment_1 = Segment([Point([dernier_pointX_1.x, 0]), Point([dernier_pointX_1.x, 1])])
result_droite = SortedX[n:]
result_gauche = SortedX[:n]
print(len(result_gauche), len(result_droite))
SortedY = sorted([point for point in result_gauche], key = ordonnee)
result_bis = prochesY(SortedY, distance)
n_bis = len(result_bis)
print(n_bis)
print(result_bis)
dernierbis = result_bis[-1]
# segment_2 = Segment([Point([0, dernierbis.y]), Point([dernier_pointX_1.x, dernierbis.y])])
result_bas = result_gauche[n_bis:]
result_haut = result_gauche[:n_bis]
print(len(result_haut), len(result_bas))
#
dernier_pointXbis_1 = result_bis[-1]
#
dernier_indice_bis = result_gauche.index(dernier_pointXbis_1)
#
result_haut = result_gauche[dernier_indice_bis + 1:]
result_bas = result_gauche[:dernier_indice_bis + 1]
#
segment_2 = Segment([Point([0, dernier_pointXbis_1.y]), Point([dernier_pointX_1.x, dernier_pointXbis_1.y])])
#
# print("*********************************")
# print(result_haut)
# print("*********************************")
# print(result_bas)
# tycat(origine, points, segment_1)
tycat(origine, points, (segment_1, segment_2))
"""
affichage des tailles triees de chaque composante
"""
segments = []
research_base = [point for point in points]
origine = Point([0.0, 0.0])
total = research_base.copy()
s = 0
while len(research_base) > 0:
current = research_base[0]
research_base.pop(0)
for point in research_base:
if current.distance_to(point) < distance:
s += 1
segments.append(Segment([current, point]))
tycat(origine, total, segments)
