Ejemplo n.º 1
0
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()
Ejemplo n.º 2
0
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()
Ejemplo n.º 3
0
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
Ejemplo n.º 4
0
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 
Ejemplo n.º 5
0
 def test_checkAttributValues_ok(self):
     df = pd.DataFrame({'attr': ['toto', 'tata']})
     self.assertTrue(O.checkAttributValues(df, 'attr', 'toto', 'tata'))
Ejemplo n.º 6
0
 def test_checkAttributsinDf_strList(self):
     df = pd.DataFrame({'toto': [1, 2, 3], 'tata': [1, 2, 3]})
     self.assertTrue(O.checkAttributsinDf(df, ['toto', 'tata']))
Ejemplo n.º 7
0
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)
Ejemplo n.º 9
0
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
Ejemplo n.º 11
0
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
Ejemplo n.º 12
0
def importimage():
    global image
    filename = askopenfilename()
    image = Outils.loadimage(filename)
    renderimage(image)
Ejemplo n.º 13
0
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)