simplification de graph

""" simplify the graph
    @G : le graph etudier
    @simplify_on : sur quoi simplifier
        ex: NDVI, CODE CULTURE...
    @criteria : quel relation simplifier
    """
    def simplify_graphV2(self, G, simplify_on, criteria):

        # condition de terminaison
        exit = False

        nombre_dispo = G.number_of_nodes()

        # graph des dummies
        G_dummy = nx.Graph()
        G_dummy = G_dummy.to_directed()

        l_priorite = ["EC", "tres_proche", "PO", "Moyen proche", "peu proche"]

        while(not exit):

            # si il n'y a plus de lien, on sort
            if not G.edges():

                exit = True
                break

            # pour chaques liens
            for u,v in G.edges() :

                # si le liens doit etre simplifier
                if ((G[u][v]["label"] == criteria) and
                (G.has_edge(v, u)) and
                (G[u][v]["label"] == criteria) and
                (G.node[u]["data"][simplify_on] == G.node[v]["data"][simplify_on])):

                    # il faut reverifier les autres liens
                    exit = False

                    # avant de fusionner les noeuds,
                    # il faut determiner quels relation transmettre

                    # pour chaque relation entrante en v
                    for a, b in G.in_edges(v):
                        if (a != u and b != u):

                            # si a n'a pas de relation vers u
                            # alors ajouter cette relation

                            if not G.has_edge(a, u):

                                G.add_edge(a, u,
                                        label = G[a][b]["label"],
                                        color = G[a][b]["color"])

                            # si u est deja en relation avec b
                            # alors regarder quel relation est prioritaire
                            # et maj si besoin

                            else:

                                label_bu = G[b][u]["label"]
                                label_ab = G[a][b]["label"]

                                # obtenont leurs rangs respectif
                                # en regardant dans la liste de priorite

                                rang_bu = l_priorite.index(label_bu)
                                rang_ab = l_priorite.index(label_ab)

                                if rang_ab < rang_bu:

                                    # il faut maj
                                    G[b][u]["label"] = label_ab



                    # meme raisonnement pour les relations sortantes
                    for a, b in G.out_edges(v):
                        if (a != u and b != u):

                            # si u n'a pas de relation vers v
                            # alors ajouter cette relation

                            if not G.has_edge(u, b):

                                G.add_edge(u, b,
                                        label = G[a][b]["label"],
                                        color = G[a][b]["color"])

                            # si u est deja en relation avec b
                            # alors regarder quel relation est prioritaire
                            # et maj si besoin

                            else:

                                label_ub = G[u][b]["label"]
                                label_ab = G[a][b]["label"]

                                # obtenont leurs rangs respectif
                                # en regardant dans la liste de priorite

                                rang_ub = l_priorite.index(label_ub)
                                rang_ab = l_priorite.index(label_ab)

                                if rang_ab < rang_ub:

                                    # il faut maj
                                    G[u][b]["label"] = label_ab


                    # on ajoute des noeuds et edges
                    # dummies

                    if not G_dummy.has_node(u):
                        G_dummy.add_node(u,
                                pos = G.node[u]["pos"])

                    if not G_dummy.has_node(v):
                        G_dummy.add_node(v,
                            pos  = G.node[v]["pos"])

                    G_dummy.add_edge(v, u, label="dummy", color = "grey")

                    # la parcelle est maintenant l'union des
                    # deux parcelles
                    new_geo = shapely.ops.unary_union(
                            [G.node[u]["data"]["geometry"],
                            G.node[v]["data"]["geometry"]])


                    G.node[u]["data"]["geometry"] = new_geo

                   # supression et maj des noeuds / liens
                    G.remove_edge(u, v)
                    G.remove_node(v)

                    break

                else:

                    exit = True

        for n in G.nodes:

            # on cherche un nr dispo
            while (G_dummy.has_node(nombre_dispo) or
                    G.has_node(nombre_dispo)):
                nombre_dispo = nombre_dispo + 1

            # mettons a jour les coordonnes des noeuds
            centroid = G.node[n]["data"]["geometry"].centroid


            # les dummies sont a jour sauf pour le noeud
            # fussiones. reglons cela
            if (G_dummy.has_node(n)
            and G.node[n]["pos"] != centroid):

                G_dummy.add_node(nombre_dispo,
                        pos = G.node[n]["pos"])

                G_dummy.add_edge(nombre_dispo, n, label="dummy", color = "grey")
                G_dummy.node[n]["pos"] = (centroid.x, centroid.y)

            G.node[n]["pos"] = (centroid.x, centroid.y)

        return G, G_dummy