def renvoyerJourneeTypeTest(date):
#remplacer sys.argv[1] par nomFichier
deb = datetime.now()
n = len(sys.argv)
for i in range(1, n):
df = Outils.puissanceReferenceMachine(sys.argv[i], date)
x = arange(0, 144, 1)
res = Outils.faireMoyenneJour(df)
plt.figure(1)
plt.plot(x, res[1::])
fin = datetime.now()
print(fin - deb)
plt.show()
def renvoyerJourneeTypeTest( date):
#remplacer sys.argv[1] par nomFichier
deb = datetime.now()
n = len(sys.argv)
for i in range(1,n):
df = Outils.puissanceReferenceMachine(sys.argv[i], date)
x = arange(0,144,1)
res = Outils.faireMoyenneJour(df)
plt.figure(1)
plt.plot(x,res[1::])
fin = datetime.now()
print(fin-deb)
plt.show()
def import_donnes_base(bdd, schema, table_graph,table_vertex, localisation='boulot' ):
"""
OUvrir une connexion vers le servuer de reference et recuperer les donn�es
en entree :
bdd : string de reference de la connexion, selon le midule Outils , fichier Id_connexions, et module Connexion_transferts
schema : schema contenant les tables de graph et de vertex
table_graph : table contennat le referentiel (cf pgr_createtopology)
table_vertex : table contenant la ecsription des vertex (cf pgr_analyzegraph)
localisation : juste un moyen d'appeler le bon fichier d'identifiants de connexions en fonction de l'ordi sur lequel je bosse
en sortie :
df : dataframe telle que telcharg�es depuis la bdd
"""
#avant tout verf que toute les colonnes necessaires au traitements sont presents
flag_col, col_manquante=Outils.check_colonne_in_table_bdd(bdd,localisation, schema, table_graph,*list_colonnes_necessaires)
if not flag_col :
raise ManqueColonneError(col_manquante)
with ct.ConnexionBdd(bdd,localisation=localisation) as c :
requete1=f"""with jointure as (
select t.*, v1.cnt nb_intrsct_src, st_astext(v1.the_geom) as src_geom, v2.cnt as nb_intrsct_tgt, st_astext(v2.the_geom) as tgt_geom
from {schema}.{table_graph} t
left join {schema}.{table_vertex} v1 on t.source=v1.id
left join {schema}.{table_vertex} v2 on t.target=v2.id
)
select j.* from jointure j, zone_test_agreg z
where st_intersects(z.geom, j.geom)"""
requete2=f"""select t.*, v1.cnt nb_intrsct_src, st_astext(v1.the_geom) as src_geom, v2.cnt as nb_intrsct_tgt, st_astext(v2.the_geom) as tgt_geom
from {schema}.{table_graph} t
left join {schema}.{table_vertex} v1 on t.source=v1.id
left join {schema}.{table_vertex} v2 on t.target=v2.id"""
df = gp.read_postgis(requete2, c.sqlAlchemyConn)
return df
def angle_3_lignes(ligne_depart, lignes_adj, noeud,geom_noeud_central, type_noeud, df_lignes) :
"""
angles 3 lignes qui se separent
en entree :
ligne_depart : sdtring : id_ign de la igne qui va separer
lignes_adj : geodf des lignes qui se separentde la ligne de depart
noeud : integer : numero du noeud central
geom_noeud_central : wkt du point central de separation
type_noeud : type du noeud centrale par rapport à la ligne de depart : 'source' ou 'target'
df_lignes : df de l'ensemble des lignes du transparent
en sortie :
lgn_cote_1 : df de la ligne qui se separe de la ligne etudie
lgn_cote_2 : df de l'autre ligne qui se separe
angle_1 : float : angle entre la ligne de depart et la 1er des lignes_adj
angle_2 : float : angle entre la ligne de depart et la 2eme des lignes_adj
angle_3 : l'ecart entre les 2 lignes qui se separent
"""
#noeud partage = noeud, dc coord_noeud_partage=
coord_noeud_partage=list(loads(geom_noeud_central).coords)[0]
lgn_cote_1=lignes_adj.iloc[0]
lgn_cote_2=lignes_adj.iloc[1]
#coord noeud non partage lignes de depart : c'est le 2eme ou avant dernier point dans la liste des points, selon le type_noeud
coord_lgn_dep_pt1=([coord for coord in df_lignes.loc[ligne_depart].geom[0].coords][1] if type_noeud=='source'
else [coord for coord in df_lignes.loc[ligne_depart].geom[0].coords][-2])
# trouver type noeud pour ligne fin et en deduire la coord du noeud suivant sur la ligne:
type_noeud_comp_lgn1='source' if lgn_cote_1['source']==noeud else 'target'
coord_lgn1_fin_pt2=([coord for coord in lgn_cote_1.geom[0].coords][1] if type_noeud_comp_lgn1=='source'
else [coord for coord in lgn_cote_1.geom[0].coords][-2])
type_noeud_comp_lgn2='source' if lgn_cote_2['source']==noeud else 'target'
coord_lgn2_fin_pt2=([coord for coord in lgn_cote_2.geom[0].coords][1] if type_noeud_comp_lgn2=='source'
else [coord for coord in lgn_cote_2.geom[0].coords][-2])
#angle entre les 2 lignes :
angle_1=Outils.angle_entre_2_ligne(coord_noeud_partage, coord_lgn_dep_pt1, coord_lgn1_fin_pt2)
angle_2=Outils.angle_entre_2_ligne(coord_noeud_partage, coord_lgn_dep_pt1, coord_lgn2_fin_pt2)
angle_3=360-(angle_1+angle_2)
return lgn_cote_1, lgn_cote_2, angle_1,angle_2,angle_3
def test_checkAttributValues_ok(self):
df = pd.DataFrame({'attr': ['toto', 'tata']})
self.assertTrue(O.checkAttributValues(df, 'attr', 'toto', 'tata'))
def test_checkAttributsinDf_strList(self):
df = pd.DataFrame({'toto': [1, 2, 3], 'tata': [1, 2, 3]})
self.assertTrue(O.checkAttributsinDf(df, ['toto', 'tata']))
def renvoyerJourneeTypeAvecMax(nomFichier, date):
#remplacer sys.argv[1] par nomFichier
df = Outils.puissanceReferenceMachine(nomFichier, date)
res = Outils.faireMoyenneJour(df)
return res
def effacement_main(date_debut, Puissance_a_effacer,
liste_temperatures_sans_effacement,
liste_temperatures_avec_effacement, liste_temperatures_ext,
liste_matrices, liste_machines, liste_consos):
##instancier: liste_machines
#Objets return
liste_dates = [date_debut + timedelta(seconds=i * 600) for i in range(7)]
liste_temp_int_simul = []
#Initialisation de la matrice renvoyée, à l'état initial
matrice = [[]]
for mac in liste_machines:
matrice[0].append([
mac.renvoyerNom(),
mac.renvoyerEtatActuel(),
mac.consoMachine(),
mac.renvoyerGene()
])
print("Hello !")
print(matrice)
Puissance_effacee = 0
plus_modifiables = [
machine for machine in liste_machines
if machine.renvoyerEtatActuel() == 0
]
nb_iter = 0
#Début de l'algorithme
while Puissance_effacee < Puissance_a_effacer and len(
plus_modifiables) != len(liste_machines):
liste_tuples = []
i = 0
for machine in liste_machines:
i += 1
if not (machine in plus_modifiables):
if machine.renvoyerGene() >= 0.95:
liste_tuples.append((0, machine))
plus_modifiables.append(machine)
elif machine.renvoyerEtatContinu():
if machine.renvoyerEtatActuel() >= 0.01:
deltagene = get_delta_gene(
machine, date_debut, liste_consos[i]
[renvoyerIndiceJournee(date) -
renvoyerIndiceJournee(origine_de_la_simulation)])
priorite = machine.consoMachine() / (deltagene * 100)
liste_tuples.append((priorite, machine))
else:
liste_tuples.append((0, machine))
machine.modifierEtatActuel(0)
plus_modifiables.append(machine)
else:
priorite = machine.renvoyerConsoMax(
) / machine.renvoyerGene()
liste_tuples.append((priorite, machine))
plus_modifiables.append(machine)
else:
liste_tuples.append((0, machine))
liste_tuples_sorted = sorted(liste_tuples, reverse=True)
machine_prior = liste_tuples_sorted[0](1)
if not (len(plus_modifiables) == len(liste_machines)
and machine_prior.renvoyerEtatContinu()):
Puissance_effacee += machine_prior.renvoyerConso()
machine_prior.actualise_etat_et_gene(machine, date_debut)
for k, mach in enumerate(liste_tuples_sorted):
matrice[nb_iter][k] = [
mach.renvoyerNom(),
mach.renvoyerEtatActuel(),
mach.consoMachine(),
mach.renvoyerGene()
]
nb_iter += 1
i = 0
#Début de la boucle temporelle:
for date in liste_dates[1::]:
i += 1
Puissance_tot = sum(
[matrice[nb_iter][x][2] for x in range(len(liste_machines))])
liste_temp_int_simul.append(
prevision_temperature(
liste_temp_int_simul[-1],
chauffage.renvoyerEtatActuel() * chauffage.renvoyerConsoMax(),
liste_temperatures_ext[
Outils.renvoyerIndiceJournee(date_debut) -
Outils.renvoyerIndiceJournee(origine_de_la_simulation)],
nom_temperature))
##fonction calcul_temp à définir en fonction de P_tot, T_préc, T_ext(date)
#retour de la liste des temps, liste temporelle des températures simulées, et la matrice pas à pas
liste_matrices.append(matrice)
def renvoyerJourneeTypeAvecMax(nomFichier, date):
#remplacer sys.argv[1] par nomFichier
df = Outils.puissanceReferenceMachine(nomFichier, date)
res = Outils.faireMoyenneJour(df)
return res
import ArithmeticOperations as AOp
import Outils
import Seuillage
import cv2 as CV
import numpy as np
srcPicture = Outils.loadimage("image.jpg")
binaryPicture = Seuillage.grayscale(srcPicture)
binaryPicture = Seuillage.binarisation(binaryPicture, 124)
def test_addColorImg_True():
global srcPicture
expected = CV.add(srcPicture, srcPicture)
result = AOp.addTwoImages(srcPicture, srcPicture, 255)
comparison = result == expected
assert comparison.all()
def test_addBinaryImg_True():
global binaryPicture
expected = CV.add(binaryPicture, binaryPicture)
result = AOp.addTwoImages(binaryPicture, binaryPicture, 255)
comparison = result == expected
assert comparison.all()
def test_subColorImg_True():
global srcPicture
def tronc_tch(ids, df_lignes) :
"""
obtenir une df des troncon touches par une ligne avec l'angle entre les lignes, le numero, le codevoie_d
attention, la geom doit etre de type multilinestring
en entree :
ids : tuple de string de id_ign
df_lignes : données issues de identifier_rd_pt() avec id_ign en index
en sortie :
df_tronc_tch : df avec les attributs precites
"""
if len(ids)==1 : #une seule lignes dans le troncon
df_ids=df_lignes.loc[ids].copy()
noeuds = [df_ids.source,df_ids.target]
list_ids_tch= df_lignes.loc[((df_lignes.target.isin(noeuds)) | (df_lignes.source.isin(noeuds))) &
(~df_lignes.index.isin(ids))].index.tolist()
list_carac_tch=[(a,b) for a,b in zip(list_ids_tch,[('source',df_lignes.loc[a].source) if df_lignes.loc[a].source in noeuds else
('target',df_lignes.loc[a].target) for a in list_ids_tch])]
list_carac_fin=[(a[0][0],a[0][1][0],a[0][1][1], a[1]) for a in zip(list_carac_tch,['source' if b[1]==df_lignes.loc[ids].source else 'target'
for a,b in list_carac_tch])]
df_tronc_tch=pd.DataFrame.from_records(list_carac_fin, columns=['id_ign', 'type_noeud_lgn', 'id_noeud_lgn', 'type_noeud_src'])
#calcul des coordonnées des points
df_tronc_tch['coord_lgn_base']=df_tronc_tch.apply(lambda x : [df_ids.geom[0].coords[i] for i in range(len(df_ids.geom[0].coords))][1] if
x['type_noeud_src']=='source' else [df_ids.geom[0].coords[i] for i in range(len(df_ids.geom[0].coords))][-2],axis=1)
df_tronc_tch['coord_lgn_comp']=df_tronc_tch.apply(lambda x : [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][1] if
x['type_noeud_lgn']=='source' else [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][-2],axis=1)
df_tronc_tch['coord_noued_centr']=df_tronc_tch.apply(lambda x : [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][0] if x['type_noeud_lgn']=='source'
else [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][-1],axis=1)
#angle
df_tronc_tch['angle']=df_tronc_tch.apply(lambda x : Outils.angle_entre_2_ligne(x['coord_noued_centr'],x['coord_lgn_comp'], x['coord_lgn_base']),axis=1)
df_tronc_tch=df_tronc_tch.merge(df_lignes[['numero','nom_1_d',df_lignes.geometry.name]], left_on='id_ign', right_index=True)
df_tronc_tch['longueur']=df_tronc_tch[df_lignes.geometry.name].apply(lambda x : x.length)
else :
df_ids=df_lignes.loc[list(ids)].copy()
noeuds=[k for k,v in Counter(df_ids.source.tolist()+df_ids.target.tolist()).items() if v==1] #liste des noeuds uniques
geom_noeuds=[loads(k).coords[0] for k,v in Counter(df_ids.src_geom.tolist()+df_ids.tgt_geom.tolist()).items() if v==1] #liste des geoms uniques
geom_ligne=linemerge(unary_union(df_ids.geom.tolist())) #agregation des lignes
pt_source=tuple([round(a,8) for a in geom_ligne.coords[0]]) #calculdes coordonées deb et fin de la lignes agregee
pt_target=tuple([round(a,8) for a in geom_ligne.coords[-1]])
df_noeud=pd.DataFrame(zip(noeuds,geom_noeuds), columns=['id_noeud', 'geom_noeud'])
df_noeud['type_noeud']=df_noeud.apply(lambda x : 'target' if x['geom_noeud']==pt_target else 'source',axis=1) #affectation du type de noeud
df_noeud.set_index('id_noeud',inplace=True)
list_ids_tch= df_lignes.loc[((df_lignes.target.isin(noeuds)) | (df_lignes.source.isin(noeuds))) &
(~df_lignes.index.isin(ids))].index.tolist()
list_carac_tch=[(a,b) for a,b in zip(list_ids_tch,[('source',df_lignes.loc[a].source) if df_lignes.loc[a].source in noeuds else
('target',df_lignes.loc[a].target) for a in list_ids_tch])]
list_carac_fin=[(a[0][0],a[0][1][0],a[0][1][1], a[1]) for a in zip(list_carac_tch,['source' if df_noeud.loc[b[1]].type_noeud=='source' else 'target'
for a,b in list_carac_tch])]
df_tronc_tch=pd.DataFrame.from_records(list_carac_fin, columns=['id_ign', 'type_noeud_lgn', 'id_noeud_lgn', 'type_noeud_src'])
#calcul des coordonnées des points
df_tronc_tch['coord_lgn_base']=df_tronc_tch.apply(lambda x : geom_ligne.coords[1][1] if
x['type_noeud_src']=='source' else geom_ligne.coords[1][-2],axis=1)
df_tronc_tch['coord_lgn_comp']=df_tronc_tch.apply(lambda x : [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][1] if
x['type_noeud_lgn']=='source' else [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][-2],axis=1)
df_tronc_tch['coord_noued_centr']=df_tronc_tch.apply(lambda x : [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][0] if x['type_noeud_lgn']=='source'
else [df_lignes.loc[x['id_ign']].geom[0].coords[i] for i in range(len(df_lignes.loc[x['id_ign']].geom[0].coords))][-1],axis=1)
#angle
df_tronc_tch['angle']=df_tronc_tch.apply(lambda x : Outils.angle_entre_2_ligne(x['coord_noued_centr'],x['coord_lgn_comp'], x['coord_lgn_base']),axis=1)
#df_tronc_tch=df_tronc_tch.merge(df_lignes[['numero','nom_1_d']], left_on='id_ign', right_index=True)
#ce qui suit n'est pas verifie, si besoin reprendre la ligne commentaire ci-dessus, mais qui ne permet pas d'avoir la geom et longueur
df_tronc_tch=df_tronc_tch.merge(df_lignes[['numero','nom_1_d',df_lignes.geometry.name]], left_on='id_ign', right_index=True)
df_tronc_tch['longueur']=df_tronc_tch[df_lignes.geometry.name].apply(lambda x : x.length)
return df_tronc_tch
def importimage():
global image
filename = askopenfilename()
image = Outils.loadimage(filename)
renderimage(image)
def recup_troncon_elementaire(id_ign_ligne, df, ligne_traite_troncon=[]):
"""
Fonction generatrice
Recuperer les lignes d'un troncon a partir d'une ligne source
gere les cas simple (ligne qui se suivent), les voies à 2 lignes, les 3 lignes qui se touchent
en entree : id d'une ligne -> str
liste des ligne traitees dans le cadre de ce troncon elementaire -> liste de str
en sortie : id de la ligne suivante -> str
"""
#donnees de la ligne
df_ligne = df.loc[id_ign_ligne]
#print(df_ligne)
nature = df_ligne.loc['nature']
#print('ligne_traite_troncon : ',ligne_traite_troncon)
ligne_traite_troncon.append(id_ign_ligne)
#yield id_ign_ligne
liste_ligne_suivantes = []
for key, value in {
'nb_intrsct_src': ['source', 'src_geom'],
'nb_intrsct_tgt': ['target', 'tgt_geom']
}.items():
#print(id_ign_ligne,key, value)
# cas simple de la ligne qui en touche qu'uen seule autre du cote source
if df_ligne.loc[key] == 2:
#print (f' cas = 2 ; src : avant test isin : {datetime.now()}, ligne : {id_ign_ligne} ')
#print(id_ign_ligne,key, value)
df_touches_source = df.loc[(
~df.index.isin(ligne_traite_troncon)
) & (
(df['source'] == df_ligne[value[0]]) |
(df['target'] == df_ligne[value[0]])
)] # recuperer le troncon qui ouche le point d'origine et qui n'est pas deja traite
#print (f' cas = 2 ; src : apres test isin : {datetime.now()}')
if len(
df_touches_source
) > 0: # car la seule voie touchee peut déjà etre dans les lignes traitees
id_ign_suivant = df_touches_source.index.tolist()[0]
liste_ligne_suivantes.append(id_ign_suivant)
#print (f'fin traitement cas = 2 ; src : apres test isin : {datetime.now()}')
ligne_traite_troncon.append(
id_ign_suivant) #liste des lignes deja traitees
#yield from recup_troncon_elementaire(id_ign_suivant, ligne_traite_troncon) #on boucle pour chercher la suivante
yield id_ign_suivant
elif df_ligne.loc[
key] >= 3: # cas plus complexe d'une ligne a un carrefour. soit c'est la meme voie qui se divise, soit ce sont d'autre voie qui touche
#print (f' cas = 3 ; src : avant test isin : {datetime.now()}')
df_touches_source = df.loc[
(~df.index.isin(ligne_traite_troncon)) &
((df['source'] == df_ligne[value[0]]) |
(df['target'] == df_ligne[value[0]])
)] # recuperer le troncon qui ouche le point d'origine
liste_ligne_touchees = df_touches_source.index.tolist()
#print (f' cas = 3 ; src : apres test isin : {datetime.now()}')
#gestion des bretelles et des rond points : si la ligne qui est traitée est dessus et que plusieurs voies en partent : on ne traite pas la ligne, elle sera traitee avec les voies qui arrivent sur le rd point
if nature == 'Bretelle' or df_touches_source['nature'].all(
) == 'Bretelle': #comme ça les bretelles sont séparrées des sections courantes, si on dispose de données de ccomptage dessus (type dira)
continue
elif nature == 'Rd_pt' and df_ligne['nb_rte_rdpt'] > 1:
ligne_traite_troncon, liste_ligne_suivantes = [], []
break
if len(liste_ligne_touchees
) > 0: # si les voies touchees n'on pas ete traiees
if (
(df_ligne.loc['numero']
== df_touches_source['numero']).all() == 1
and (df_ligne.loc['numero'] != 'NC')
): # pour les voies hors voies communales si elles ont le mm nom on prend toutes les lignes, pour les voies communales dont les nom_voie_g sont equivalent c'est pareil
#gestion des rd points
if df_touches_source['nature'].any(
) == 'Rd_pt': #si une des lignes touchées est un rd point on prend toutes les autres du m^me rd point
id_rdpt = df_touches_source.iloc[0][
'id_rdpt'] #recuperer l'id du rd pt
nb_rte_rdpt = df_touches_source.iloc[0][
'nb_rte_rdpt'] #recuperer le nb de route qui croise le rd point
liste_ligne_touchees += df.loc[(
df['id_rdpt'] == id_rdpt
) & (
~df.index.isin(liste_ligne_touchees)
)].index.tolist(
) #recuperer les lignes de cet id_drpt non deja recuperee
#print(f'ligne{id_ign_ligne} rd point {liste_ligne_touchees}, nb rroute rd pt {nb_rte_rdpt}')
if nb_rte_rdpt > 1: #si le rd point concentre plusieurs routes différentes, on stocke kes voies du rond point mais on ne traite pas les autres voies du mm nom qui en sortent
for id_ign_suivant in liste_ligne_touchees:
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
else: # a l'inverse, si le rond point ne traite qu'une seule route, on associe le rd pt + les voies qui en sortent au mm troncon
for id_ign_suivant in liste_ligne_touchees:
liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
else:
for id_ign_suivant in liste_ligne_touchees:
#print (f'fin traitement cas = 3 mm numero ; src : apres test isin : {datetime.now()}')
liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
#yield from recup_troncon_elementaire(id_ign_suivant, ligne_traite_troncon)
yield id_ign_suivant
elif ((df_ligne.loc['codevoie_d']
== df_touches_source['codevoie_d']).all() == 1
and (df_ligne.loc['numero'] == 'NC')
and df_touches_source['numero'].all()
== 'NC'): #si les voies qui se croisent sont les memes
if df_touches_source['nature'].any(
) == 'Rd_pt': #si une des lignes touchées est un rd point on prend toutes les autres du m^me rd point
id_rdpt = df_touches_source.iloc[0][
'id_rdpt'] #recuperer l'id du rd pt
liste_ligne_touchees += df.loc[(
df['id_rdpt'] == id_rdpt
) & (
~df.index.isin(liste_ligne_touchees)
)].index.tolist(
) #recuperer les lignes de cet id_drpt non deja recuperee
#print(f'ligne{id_ign_ligne} rd point {liste_ligne_touchees}, nb rroute rd pt {nb_rte_rdpt}')
for id_ign_suivant in liste_ligne_touchees:
liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
else:
for id_ign_suivant in liste_ligne_touchees:
#print (f'fin traitement cas = 3 mm numero ; src : apres test isin : {datetime.now()}')
liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
#yield from recup_troncon_elementaire(id_ign_suivant, ligne_traite_troncon)
yield id_ign_suivant
elif (
df_ligne.loc['numero'] == 'NC' and len(
set(df_touches_source['codevoie_d'].values.tolist(
))) == 2 and 'NR'
in df_touches_source['codevoie_d'].values.tolist()
and (df_touches_source['numero'] == 'NC').all()
and df_ligne.loc['codevoie_d']
in df_touches_source['codevoie_d'].values.tolist()
): #si les voies croisés ont un nom pour ue d'entre elle et l'autre non
df_touches_source = df_touches_source.loc[
df_touches_source['codevoie_d'] == df_ligne[
'codevoie_d']] #on limite le df touche sources aux voies qui ont le même nom
liste_ligne_touchees = df_touches_source.index.tolist()
if df_touches_source['nature'].any(
) == 'Rd_pt': #si une des lignes touchées est un rd point on prend toutes les autres du m^me rd point
id_rdpt = df_touches_source.iloc[0][
'id_rdpt'] #recuperer l'id du rd pt
liste_ligne_touchees += df.loc[(
df['id_rdpt'] == id_rdpt
) & (
~df.index.isin(liste_ligne_touchees)
)].index.tolist(
) #recuperer les lignes de cet id_drpt non deja recuperee
#print(f'ligne{id_ign_ligne} rd point {liste_ligne_touchees}, nb rroute rd pt {nb_rte_rdpt}')
for id_ign_suivant in liste_ligne_touchees:
#liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
else:
for id_ign_suivant in liste_ligne_touchees:
#print (f'fin traitement cas = 3 mm numero ; src : apres test isin : {datetime.now()}')
liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
#yield from recup_troncon_elementaire(id_ign_suivant, ligne_traite_troncon)
yield id_ign_suivant
elif (
df_ligne.loc['numero'] == 'NC'
and (df_touches_source['nature'] == 'Rd_pt').all()
and df_touches_source['assigne_rdpt'].all() == False
): #si on touche un rond point dont on ne peut pas affecter le nom, on va lui affecter un id arbitraire, mais pas au lignes suivantes
id_rdpt = df_touches_source.iloc[0]['id_rdpt']
liste_ligne_touchees += df.loc[
(df['id_rdpt'] == id_rdpt) &
(~df.index.isin(liste_ligne_touchees))].index.tolist()
for id_ign_suivant in liste_ligne_touchees:
#liste_ligne_suivantes.append(id_ign_suivant)
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
else: #si toute les voies n'ont pas le même nom
if nature in ['Autoroute', 'Quasi-autoroute']:
df_ligne_autre = df_touches_source.loc[
df_touches_source['numero'] != df_ligne['numero']]
if len(df_touches_source) - len(
df_ligne_autre
) > 0: #sinon ce veut dire que le troncon suivant est deja traite
df_ligne_pt_avant_src = df_ligne['geom'][0].coords[
1] #point avant le point target
coord_source_arrondi = [
round(i, 1) for i in list(
loads(df_ligne[value[1]]).coords)[0]
] #coordonnees du point target
#trouver le point de df_ligne autre juste aprs le point source
coord_ligne_arrondi = [
[round(coord[0], 1),
round(coord[1], 1)]
for coord in list((
df_ligne_autre.geometry.iloc[0])[0].coords)
] #(df_ligne_autre.geometry.iloc[0]) la geometryde la 1ere ligne
pt_suivant_src_ligne_autre = coord_ligne_arrondi[
-2] if coord_ligne_arrondi[
-1] == coord_source_arrondi else coord_ligne_arrondi[
1]
#recuperer l'angle
angle = Outils.angle_entre_2_ligne(
coord_source_arrondi,
pt_suivant_src_ligne_autre,
df_ligne_pt_avant_src)
#si l'angle estdans les 90°, on ignor et on continue sur la l'autre ligne
if 55 < angle < 135:
id_ign_suivant = df_touches_source.loc[
~df.id.isin(df_ligne_autre.id
)].index.values.tolist()[0]
liste_ligne_suivantes.append(id_ign_suivant)
#print (f'fin traitement cas = 3 ; src : apres test isin : {datetime.now()}')
ligne_traite_troncon.append(id_ign_suivant)
yield id_ign_suivant
#yield from recup_troncon_elementaire(id_ign_suivant, ligne_traite_troncon)
#print(f'ligne : {id_ign_ligne}, liste a traiter : {liste_ligne_suivantes}' )
for ligne_a_traiter in liste_ligne_suivantes:
yield from recup_troncon_elementaire(ligne_a_traiter, df,
ligne_traite_troncon)