commentaires

coord_to_intersections.py

@@ -6,79 +6,94 @@ def coord_to_inter(liste_coord,lat,long,main_street):
     inter_street=[]
     inter_street_coord=[]
     for inter in liste_coord:
+        #Calcul des distances entre les intersections et l'arbre
         d=(inter[0]-long)**2 + (inter[1]-lat)**2
         dist.append(d)
     while len(inter_street)<1 :
+        #On regarde l'intersection la plus proche de l'arbre
         candidat=liste_coord[dist.index(min(dist))]
-        #print(candidat)
+        #On regarde si cette intersection correspond bien au croisement avec une autre rue, on trouve le nom de cette autre rue
         nom_de_rue=circular_research(candidat[1], candidat[0], main_street)
         if nom_de_rue== None :
+            #Si on ne trouve pas d'autre rue a cette intersection on écarte cette intersection
             indice=dist.index(min(dist))
             dist.pop(indice)
             liste_coord.pop(indice)
         else : 
+            #Si on trouve, on a notre début de tronçon
             inter_street.append(nom_de_rue)
             inter_street_coord.append(candidat)
             indice=dist.index(min(dist))
             d_1 = min(dist)
             dist.pop(indice)
             liste_coord.pop(indice)
-    #Calcul du tronçon de l'autre coté
+    print('Début du tronçon trouvé')
+    #Recherche de la fin du tronçon
     liste_coord_admissibles = []
     d_1_2 = []
     dist2 = []
     for i in range(len(liste_coord)):
         #On prend la liste des intersection situé du second coté de l'arbe
+        #Pour cela on calcule les distances entre le premier point trouvé, l'arbre et les autres points
+        #On conserve les points qui permettent de former un triangle avec un angle obtu au niveau de l'arbre
         d=(liste_coord[i][0]-inter_street_coord[0][0])**2 + (liste_coord[i][1]-inter_street_coord[0][1])**2
         if d > dist[i] + d_1:
             liste_coord_admissibles.append(liste_coord[i])
             d_1_2.append(d)
             dist2.append(dist[i])
     while len(inter_street)<2 :
+        #On regarde l'intersection admissible la plus proche du début du tronçon
         candidat=liste_coord_admissibles[d_1_2.index(min(d_1_2))]
         nom_de_rue=circular_research(candidat[1], candidat[0], main_street)
         if nom_de_rue== None :
+            #Si cette intersection ne donne rien, on la rejette
             indice=d_1_2.index(min(d_1_2))
             d_1_2.pop(indice)
             liste_coord_admissibles.pop(indice)
             dist2.pop(indice)
         elif nom_de_rue==inter_street[0]:
+            #Si l'intersection est la même rue que le début de tronçon, on rejette
             indice=d_1_2.index(min(d_1_2))
             d_1_2.pop(indice)
             liste_coord_admissibles.pop(indice)
             dist2.pop(indice)
         else : 
+            #Sinon on à trouvé la fin de tronçon
             inter_street.append(nom_de_rue)
             inter_street_coord.append(candidat)
             indice=d_1_2.index(min(d_1_2))
             d_2 = dist2[indice]
             liste_coord_admissibles.pop(indice)
+    print('fin du tronçon trouvé')
     print(inter_street)
+    #On souhaite ensuite s'asssurer que l'on à le couple début/fin de tronçon le plus rapproché possible pour
+    #réduire la zone de recherche
     liste_coord_admissibles2 = []
     d_2_1 = []
-    #dist = fct_dist(liste_coord, lat, long)
     for i in range(len(liste_coord)):
         #On prend la liste des intersection situé du premier coté de l'arbe
+        #Pour cela on calcule les distances entre le second point trouvé, l'arbre et les autres points
+        #On conserve les points qui permettent de former un triangle avec un angle obtu au niveau de l'arbre
         d=(liste_coord[i][0]-inter_street_coord[1][0])**2 + (liste_coord[i][1]-inter_street_coord[1][1])**2
-        print(liste_coord[i])
-        print(d - dist[i] - d_2)
-        if d > dist[i] + d_2:  #+ 2* 10**(-12)
+
+        if d > dist[i] + d_2:  
             liste_coord_admissibles2.append(liste_coord[i])
             d_1_2.append(d)
     inter_street2 = ['', '']
     c = 0
     while inter_street != inter_street2:
+        print('MaJ ', c+1)
+        #Calcul des intersections admissibles et des distances
         if c % 2 == 0:
             liste_coord_admissibles2 += [inter_street_coord[0]]
             d_2_1 = fct_d_2_1(liste_coord_admissibles2, inter_street_coord)
-            #print(liste_coord_admissibles2)
-            #print(d_2_1)
         else:
             liste_coord_admissibles += [inter_street_coord[1]]
             d_1_2 = fct_d_2_1(liste_coord_admissibles, inter_street_coord)
             print(d_1_2)
 
         inter_street2 = deepcopy(inter_street)
+        #Recherche du nouveau tronçon optimal
         inter_street, inter_street_coord = opti_inter_street(c, main_street, liste_coord_admissibles, liste_coord_admissibles2, d_1_2, d_2_1, inter_street, inter_street_coord)
         c +=1
     return inter_street+inter_street_coord

main.py

@@ -43,11 +43,14 @@ def classement_arbres(liste_coord):
     return dict
 
 if __name__=="__main__":
-    lat = 48.89394122
-    lon = 2.247959188
+    
+    lat = 48.89627806
+    lon = 2.248657510
     print(tree_position(lat, lon))
+    '''
     lat = 48.89227652
     lon = 2.253773690
     #print(tree_position(lat, lon))
     liste=[(2.24697,48.89535),(2.24705,48.89529),(2.2472,48.89518)]
     print(trees_positions(liste))
+    '''
\ No newline at end of file

request.py

@@ -4,6 +4,7 @@ import requests
 
 
 def requete_osm(lat, lon):
+    #Recherche l'addresse d'un point gps
     params = {
         'lat':lat,
         'lon':lon,

request2.py

@@ -2,6 +2,7 @@ import requests
 import json
 
 def search_osm(main_street, city, country):
+    #requete pour obtenir les intersections d'une rue donnée
     params = {
         'street' : main_street,
         'city' : city,
@@ -16,6 +17,7 @@ def search_osm(main_street, city, country):
     return reqJson
 
 def all_intersect(json):
+    #concaténation des intersections des différents morceaux de rue trouvés
     intersection = []
     for road in json:
         try:

research.py

@@ -2,6 +2,7 @@ from request import requete_osm
 from math import sqrt
 
 def circular_research(lat, lon, main_street):
+    #Recherche un rue autre que main_street par recherche circulaire autour du point d'intersection
     street = requete_osm(lat, lon)['address']['road']
     if not(street == main_street) and not(street == ''):
         return street
@@ -15,6 +16,7 @@ def circular_research(lat, lon, main_street):
     return None
 
 def check_position(lat, lon, step, main_street, i):
+    #Calcul les positions autour du point centrale et récupère la rue associée à cette position
     street = ''
     step_diag = step/sqrt(2)
     if i == 0: