Skip to content
Snippets Groups Projects
Select Git revision
  • 8e6fb934e0a36d66c9a8f6d59a2f9fbec1abd329
  • master default
  • dockerization
  • staging
  • backup-before-cleaning-repo
  • dockerfiles-pour-maelle
6 results

index.js

Blame
  • Forked from an inaccessible project.
    research.py 4.28 KiB
    from request import requete_osm
    from math import sqrt, sin, cos, pi
    from concurrent.futures import ThreadPoolExecutor
    import time
    
    def circular_research(lat, lon, main_street):
        #Recherche un rue autre que main_street par recherche circulaire autour du point d'intersection
        try:
            street = requete_osm(lat, lon)['address']['road']
        except KeyError:
            street = ''
        #si on trouve une rue qui convient
        if not(street == main_street) and not(street == ''):
            return street
        #sinon, on cherche autour de ce point
        step = 5*10**(-5)
        #on limite la taille du "cercle" de recherche pour ne pas tomber sur des rues trop éloignées
        while step < 6*10**(-5):
            for i in range(8):
                street = check_position(lat, lon, step, main_street, i)
                if not(street == main_street) and not(street == ''):
                    return street
            step += 4*10**(-5)
        #si on n'a toujours rien trouvé, c'est que le point d'intersection ne correspond pas
        #  à une intersection avec une rue différente de main street
        return None
    
    def circular_research_2(lat, lon, main_street=''):
        #Recherche une rue autre que vide par recherche circulaire autour du point d'intersection
        #cette fonction est appelée lorsqu'on ne trouve pas de rue associée à un arbe
        #la seule différence avec la fonction précédente est donc qu'ici on impose de renvoyer une rue
        #quitte à s'éloigner énormément de l'arbre, il n'y a donc pas ici de limite pour la taille du "cercle"
        #on peut donc traiter le cas où l'arbre est au milieu d'un parc par exemple
        step = 2*10**(-5)
        found = False
        while not(found):
            for i in range(8):
                street = check_position(lat, lon, step, main_street, i)
                if not(street == main_street):
                    return street
            step += 2*10**(-5)
        return street
    
    def check_position(lat, lon, step, main_street, i):
        #i compris entre 0 et 7
        #Calcul les positions autour du point central et récupère la rue associée à cette position
        #cette fonction peut être appelée jusqu'à 8 fois
        street = ''
        step_diag = step/sqrt(2)
        if i == 0:
            try:
                street = requete_osm(lat+step, lon)['address']['road']
            except KeyError:
                pass
        elif i == 1:
            try:
                street = requete_osm(lat+step_diag, lon+step_diag)['address']['road']
            except KeyError:
                pass
        elif i == 2:
            try:
                street = requete_osm(lat, lon+step)['address']['road']
            except KeyError:
                pass
        elif i == 3:
            try:
                street = requete_osm(lat-step_diag, lon+step_diag)['address']['road']
            except KeyError:
                pass
        elif i == 4:
            try:
                street = requete_osm(lat-step, lon)['address']['road']
            except KeyError:
                pass
        elif i == 5:
            try:
                street = requete_osm(lat-step_diag, lon-step_diag)['address']['road']
            except KeyError:
                pass
        elif i == 6:
            try:
                street = requete_osm(lat, lon-step)['address']['road']
            except KeyError:
                pass
        elif i == 7:
            try:
                street = requete_osm(lat+step_diag, lon-step_diag)['address']['road']
            except KeyError:
                pass
        return street
    
    
    def multi_position(lat, lon, step):
        #test de multrithreading mais cela n'améliore pas énormément la vitesse de calcul
        #donc pas utilisé finalement
        latitude = []
        longitude = []
        for j in range(1,4):
            stp = j*step
            for i in range(8):
                latitude.append(lat+stp*cos(i*2*pi/8))
                longitude.append(lon+stp*sin(i*2*pi/8))
        with ThreadPoolExecutor(max_workers=30) as executor:
            streets = executor.map(requete_osm, latitude, longitude)
            executor.shutdown(wait=True)
        return streets
    
    if __name__=="__main__": 
        lat = 48.89494122
        lon = 2.247959188
        step = 10**(-5)
        main_street = 'Avenue Gambetta'
        t1 = time.time()
        streets = multi_position(48.89494122, 2.247959188, 10**(-5))
        t2 = time.time()
        #print(len(list(streets)))
        print(t2-t1)
        t1 = time.time()
        for j in range(1,4):
            stp = j*step
            for i in range(8):
                check_position(lat, lon, stp, main_street, i)
        t2 = time.time()
        print(t2-t1)