def txn_view_serial(conflict_status, graph_status, *txns):

    dataset = set([txns[i][j][2] for i in range(len(txns)) for j in range(len(txns[0])) if txns[i][j] != "*"])
    edges = list()

    for d in dataset:
        update_list = list()
        first_reads = list()
        last_update = ""
        for i in range(len(txns[0])):
            for j in range(len(txns)):
                if txns[j][i] == "*":
                    continue
                if txns[j][i][2] == d:
                    if txns[j][i][0] == "W":
                        update_list.append(f"T{j + 1}")
                        last_update = f"T{j + 1}"
                    if txns[j][i][0] == "R":
                        if not last_update:
                            first_reads.append(f"T{j + 1}")
                        else:
                            edges.append((last_update, f"T{j + 1}"))

        update_list_read = list(set(update_list) - set(first_reads))
        update_list = list(set(update_list))

        if first_reads:
            edges.extend([(x, y) for x in first_reads for y in update_list_read if x != y])
        if last_update:
            edges.extend([(x, last_update) for x in update_list if x != last_update])

    edges = [(e[0], e[1]) for e in edges if e[0] != e[1]]
    edges = list(set(edges))
    graph = nx.DiGraph()
    graph.add_nodes_from([f"T{x + 1}" for x in range(len(txns))])
    graph.add_edges_from(edges)

    if conflict_status and not blind_write(dataset, *txns):
        graph.clear()
        print("There is no Blind Write!")
        graph = graph_status

    try:
        nx.planar_layout(graph)
    except nx.exception.NetworkXException:
        pass

    try:
        nx.find_cycle(graph)
        plt.title("Not View Serializable", fontsize=10, color="red")
        print("This schedule is not View Serializable.")
        print()
        nx.draw(graph, with_labels=True, node_size=1500, font_size=20, font_color="yellow", font_weight="bold", connectionstyle='arc3, rad = 0.1')
    except nx.exception.NetworkXNoCycle:
        plt.title(f"View Serializable: <{','.join(nx.topological_sort(graph))}>", fontsize=10, color="red")
        print(f"This schedule is View Serializable and View Equivalent to <{','.join(nx.topological_sort(graph))}>")
        print()
        nx.draw(graph, with_labels=True, node_size=1500, font_size=20, font_color="yellow", font_weight="bold", connectionstyle='arc3, rad = 0.1')

    plt.show()
def txn_conflict_serial(*txns):

    edges = list()
    for i in range(len(txns)):
        flag = 0
        for j in range(len(txns[0])):
            if flag:
                break
            if txns[i][j] != "*":
                if txns[i][j][0] == "W":
                    for m in range(len(txns)):
                        if m == i:
                            continue
                        for n in range(j + 1, len(txns[0])):
                            if txns[m][n] == "*":
                                continue
                            if txns[i][j][2] == txns[m][n][2]:
                                if (f"T{i + 1}", f"T{m + 1}") not in edges:
                                    edges.append((f"T{i + 1}", f"T{m + 1}"))
                                flag = 1
                                break
                if txns[i][j][0] == "R":
                    for m in range(len(txns)):
                        if m == i:
                            continue
                        for n in range(j + 1, len(txns[0])):
                            if txns[m][n] == "*" or txns[m][n][0] == "R":
                                continue
                            if txns[i][j][2] == txns[m][n][2]:
                                if (f"T{i + 1}", f"T{m + 1}") not in edges:
                                    edges.append((f"T{i + 1}", f"T{m + 1}"))
                                flag = 1
                                break

    graph = nx.DiGraph()
    graph.add_nodes_from([f"T{i + 1}" for i in range(len(txns))])
    graph.add_edges_from(edges)

    try:
        nx.planar_layout(graph)
    except nx.exception.NetworkXException:
        pass

    try:
        nx.find_cycle(graph)
        plt.title("Not Conflict Serializable", fontsize=10, color="red")
        print("This schedule is not Conflict Serializable.")
        print()
        nx.draw(graph, with_labels=True, node_size=1500, font_size=20, font_color="yellow", font_weight="bold", connectionstyle='arc3, rad = 0.1')
        plt.show()
        return 1, graph
    except nx.exception.NetworkXNoCycle:
        plt.title(f"Conflict Serializable: <{','.join(nx.topological_sort(graph))}>", fontsize=10, color="red")
        print(f"This schedule is Conflict Serializable and Conflict Equivalent to <{','.join(nx.topological_sort(graph))}>")
        print()
        nx.draw(graph, with_labels=True, node_size=1500, font_size=20, font_color="yellow", font_weight="bold", connectionstyle='arc3, rad = 0.1')
        plt.show()
        return 0, ""
Пример #3
0
def draw_Lineage(Lineage, cluster_label, ax):
    uni_lab = np.unique(cluster_label)
    rootedTree = nx.DiGraph()
    for i in range(len(np.where(Lineage != -1)[0])):
        rootedTree.add_edge(uni_lab[Lineage[Lineage != -1][i]],
                            uni_lab[np.where(Lineage != -1)[0][i]])
    nx.draw(rootedTree, pos=nx.planar_layout(rootedTree, 1), ax=ax)
    nx.draw_networkx_labels(rootedTree,
                            pos=nx.planar_layout(rootedTree),
                            ax=ax)
    return ax
Пример #4
0
 def test_smoke_empty_graph(self):
     G = []
     nx.random_layout(G)
     nx.circular_layout(G)
     nx.planar_layout(G)
     nx.spring_layout(G)
     nx.fruchterman_reingold_layout(G)
     nx.spectral_layout(G)
     nx.shell_layout(G)
     nx.bipartite_layout(G, G)
     nx.spiral_layout(G)
     nx.kamada_kawai_layout(G)
Пример #5
0
 def test_smoke_string(self):
     G = self.Gs
     nx.random_layout(G)
     nx.circular_layout(G)
     nx.planar_layout(G)
     nx.spring_layout(G)
     nx.fruchterman_reingold_layout(G)
     nx.spectral_layout(G)
     nx.shell_layout(G)
     nx.spiral_layout(G)
     nx.kamada_kawai_layout(G)
     nx.kamada_kawai_layout(G, dim=1)
     nx.kamada_kawai_layout(G, dim=3)
Пример #6
0
def show_weighted_graph(G):
    pos = nx.planar_layout(G)
    nx.draw(G, pos)
    labels = nx.get_edge_attributes(G, 'weight')
    nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)

    plt.show()
Пример #7
0
def draw_subtree(G, T):
    pos = nx.planar_layout(G)
    nx.draw_networkx(G, pos)
    labels = nx.get_edge_attributes(G, 'weight')
    nx.draw_networkx_edge_labels(
        G,
        pos,
        edge_labels=labels,
    )
    nx.draw_networkx_edges(
        G,
        pos,
        edgelist=T.edges(),
        width=8,
        alpha=0.5,
        edge_color='r',
    )
    nx.draw_networkx_nodes(G,
                           pos,
                           nodelist=T.nodes(),
                           node_color='r',
                           node_size=500,
                           alpha=0.8)
    plt.show()


# Function to draw the subtree
Пример #8
0
def do_graph(args):
    AS_countries = load_AS_countries()
    country_continent = load_country_continent()

    ASNs = nx.convert_node_labels_to_integers(nx.read_gml(args.file))

    core = extract_core(ASNs)

    print("Positioning")

    pos = {}
    for node in ASNs.nodes():
        pos[node] = wiggle((0.5, 0.5) if node in core else initial_positions[
            country_continent[AS_countries[node]]] if node in AS_countries else
                           (0.5, 0.5), 0.1)

    if args.layout == "spring":
        pos = nx.spring_layout(ASNs, pos=pos)
    elif args.layout == "kamada-kawai":
        pos = nx.kamada_kawai_layout(ASNs, pos=pos)
    elif args.layout == "spectral":
        pos = nx.spectral_layout(ASNs, pos=pos)
    elif args.layout == "planar":
        pos = nx.planar_layout(ASNs, pos=pos)
    elif args.layout == "random":
        pos = nx.random_layout(ASNs, pos=pos)
    elif args.layout == "shell":
        pos = nx.shell_layout(ASNs, pos=pos)

    labels = {}

    if args.degree_display is not None:
        print("Assigning labels")
        for node, degree in ASNs.degree():
            if degree > args.degree_display:
                labels[node] = node

    print("Drawing")
    nx.draw(
        ASNs,
        pos,
        arrowstyle="->",
        with_labels=False,
        node_color=[
            "r" if x in core else colors[country_continent[AS_countries[x]]]
            if x in AS_countries else "black" for x in ASNs.nodes()
        ],
        node_size=[3 * x**(2 / 3) for _, x in ASNs.degree()],
        width=0.3,
        edge_color="grey",
        alpha=0.7)

    if args.degree_display is not None:
        print("drawing labels")
        nx.draw_networkx_labels(ASNs, pos, labels, font_size=8)

    if args.output_file is not None:
        plt.savefig(args.output_file, dpi=args.dpi)

    plt.show()
Пример #9
0
 def plot(self):
     pos = nx.planar_layout(self)
     nc = ['c' for _ in range(self.number_of_nodes())]
     plt.figure("Dependency Graph", figsize=(10, 10))
     nx.draw_networkx_nodes(self,
                            pos,
                            node_color=nc,
                            cmap=plt.get_cmap('jet'),
                            node_size=900)
     nx.draw_networkx_labels(
         self, pos,
         dict(
             map(lambda x: (x[0], x[1]),
                 nx.get_node_attributes(self, 'char').items())))
     nx.draw_networkx_edges(self,
                            pos,
                            edgelist=self.edges(),
                            edge_cmap=plt.cm.Wistia,
                            width=2,
                            arrows=True,
                            arrowstyle='-|>',
                            arrowsize=20,
                            node_size=1000)
     plt.draw()
     plt.show()
Пример #10
0
def draw_network(connections):
    # Connection Containers
    con_from = []
    con_to = []

    # Fill connection containers from our connections list
    for i in connections:
        con_from.append(i[0])
        con_to.append(i[1])

    # Create a dataframe to represent our connections
    df = pd.DataFrame({"from": con_from, "to": con_to})

    # Produce the edges from the dataframe
    G = nx.from_pandas_edgelist(df, "from", "to")

    # Color our nodes
    node_colors = ["green"] + ["skyblue"] * (len(G.nodes()) - 2) + ["red"]

    # Apply the colors to the nodes
    carac = pd.DataFrame({'ID': G.nodes(), 'myvalue': node_colors})
    carac = carac.set_index('ID')
    carac = carac.reindex(G.nodes())

    # Type of graph we want, in this case a planar graph representation
    pos = nx.planar_layout(G)
    # Draw the graph
    nx.draw(G,
            pos=pos,
            node_size=100,
            node_color=carac['myvalue'],
            with_labels=True)  # , node_color="skyblue")
    plt.show()
Пример #11
0
def draw_subtree(G,T):
    """ creates and shows the weightwed graph

    Parameters
    ----------
    G : NetworkX graph or list of nodes
    T = Subtree, gets edge attributes

    Returns
    -------
    The corresponding subtree of the weighted graph
    """
    pos = nx.planar_layout(G) ## 
    nx.draw_networkx(G,pos)   
    labels = nx.labels = nx.get_edge_attributes(G,'weight') 
    nx.draw_networkx_edge_labels(G,                  
                                 pos,           ## Creates edge labels for subtree using graph layout, position and weights
                                 edge_labels = labels)
    nx.draw_networkx_edges(G, 
                           pos, 
                           edgelist=T.edges(),   #### Draws tree's edges using graph layout
                           width=8, alpha=0.5,     ### and assigns other attributes (e.g. color, width) to network edges
                           edge_color='r')
    nx.draw_networkx_nodes(G, 
                           pos,                 ### Draws tree's nodes using layout 
                           nodelist=T.nodes(),   ## and ssigns other attributes (e.g. size, color) to network nodes
                           node_size=500, 
                           alpha=0.5, 
                           node_color='r')
    plt.show()                                  ## shows plot
Пример #12
0
def generateSpectralLayout(layout: Layout):
    positions = nx.spectral_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.planar_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.circular_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.bipartite_layout(layout.G, nx.bipartite.sets(layout.G)[0])
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.shell_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.random_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()

    positions = nx.spiral_layout(layout.G)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()
Пример #13
0
def main(harfile_path, cur_domain):
    g=nx.Graph()
    pos=nx.planar_layout(g)
    g.add_node(cur_domain)
    domains=set()
    #harfile = open('G:\Privacy\hw3\www.macys.com_Archive [19-10-11 16-36-30].har', 'r')
    harfile = open(harfile_path, encoding="utf8")
    harfile_json = json.loads(harfile.read())
    i = 0
    for entry in harfile_json['log']['entries']:
        i = i + 1
        url = entry['request']['url']
        urlparts = urlparse(url)
        res = get_tld(url, as_object=True)
        subdomain=res.subdomain
        maindomain=res.domain
        thisdomain= res.fld
        if maindomain != cur_domain and thisdomain not in domains and thisdomain !=cur_domain:
                print (thisdomain)
                domains.add(thisdomain)
            
    for dm in domains:
        if dm != cur_domain:
            g.add_node(dm,node_color='#FFFF33')
            e= g.add_edge(dm, cur_domain)
    nx.draw(g, with_labels=True, font_size=8)
    plt.show()
    print('')
Пример #14
0
Файл: main.py Проект: hkujy/VC
def disrupt_network_edge(H, edges): #edges is the list of disrupted links (list of tuples)
    H.remove_edges_from(edges)
    fig = plt.figure(figsize=(10, 9))
    pos = nx.planar_layout(H)
    nx.draw_networkx(H, pos=pos)
    fig.savefig('SF_network_disrupted.png', dpi=fig.dpi)
    return H
Пример #15
0
 def show(self) -> None:
     plt.subplot(111)
     pos = nx.planar_layout(self.G)
     nx.draw(self.G, pos=pos, with_labels=True)
     nx.draw_networkx_edges(self.G, pos,  edgelist=self.feedbacks, with_labels=True,
                            edge_color='r', connectionstyle='arc3, rad=0.5')
     plt.show()
Пример #16
0
    def plot(self, label_as_index=False, position=None, filepos=None):
        """Plot the graph in a matplotlib graph.

        :param bool label_as_index: Display the index vertex instead of the label if True. (Default False)
        :param iterable position: The position for the
        """

        G = nx.Graph()
        G.add_nodes_from([(i, {
            "label": self.label[i]
        }) for i in range(len(self.label))])
        edges = self.get_edges()
        for edge in edges:
            G.add_edge(edge[0], edge[1], weight=edge[2])
        if filepos is not None:
            pos = read_coordinates(filepos)
        elif position is not None:
            pos = position
        else:
            pos = nx.planar_layout(G) if position is None else position
        nx.draw(G, pos, with_labels=label_as_index, font_weight='bold')
        if not label_as_index:
            nx.draw_networkx_labels(
                G, pos, dict(zip(range(len(self.label)), self.label)))
        labels = nx.get_edge_attributes(G, 'weight')
        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
Пример #17
0
def generatePlanarLayout(layout: Layout):
    positions = nx.planar_layout(layout.G)
    print('Positions for all the cells:', positions)
    print(positions)
    nx.draw(layout.G, positions)
    plt.show()
    plt.savefig('test.png')
Пример #18
0
def draw_subtree(G, T):  # defines and displays the sub-graph
    pos = nx.planar_layout(G)
    nx.draw_networkx(G, pos)
    labels = nx.get_edge_attributes(G, 'weight')
    nx.draw_networkx_edge_labels(
        G,  #displays the labels of edges of the Sub-Graph
        pos,
        edge_labels=labels,
    )
    nx.draw_networkx_edges(
        G,
        pos,  #displays the edges of the Sub-Graph
        edgelist=T.edges(),
        width=8,
        alpha=0.5,
        edge_color='r',
    )
    nx.draw_networkx_nodes(
        G,  #displays the nodes of theSub- Graph
        pos,
        nodelist=T.nodes(),
        node_color='r',
        node_size=500,
        alpha=0.8)
    plt.show()
Пример #19
0
def print_graph(g, DIRECTED):
    if DIRECTED: G = nx.DiGraph()
    else: G = nx.Graph()
    for i in range(len(g)):
        G.add_node(i)
    for i in range(len(g)):
        for j in range(len(g[i])):
            G.add_edge(i, g[i][j][0], weight=g[i][j][1])
    for i in range(len(g)):
        print("from node %02i: " % (i), end="")
        print(g[i])
    try:
        pos = nx.planar_layout(G)
        nx.draw(G, pos, with_labels=True)
    except nx.NetworkXException:
        print("\nGraph is not planar, using alternative representation")
        pos = nx.spring_layout(G)
        nx.draw(G, pos, with_labels=True)
    if DIRECTED:
        labels = dict([((
            u,
            v,
        ), d['weight']) for u, v, d in G.edges(data=True)])
        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels, label_pos=0.3)
    else:
        labels = nx.get_edge_attributes(G, 'weight')
        nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
Пример #20
0
    def __init__(self, input_matrix, matrix_type):
        """
        PMFG class creates the Planar Maximally Filtered Graph and stores it as an attribute.

        :param input_matrix: (pd.Dataframe) Input distance matrix
        :param matrix_type: (str) Matrix type name (e.g. "distance").
        """
        super().__init__(matrix_type)

        # To store the MST edges
        self.mst_edges = []

        # Create a nx.Graph object from ALSMT dataframe
        self.graph = self.create_pmfg(input_matrix)

        # Create positions
        with warnings.catch_warnings():  # Silencing specific FutureWarning
            warnings.filterwarnings(
                'ignore', r'arrays to stack must be passed as a "sequence"')
            self.pos = nx.planar_layout(self.graph)

        # Attribute to store 3 cliques and 4 cliques
        self.three_cliques = []
        self.four_cliques = []

        # Generate the cliques
        self._generate_cliques()

        # Calculate disparity measure for the cliques
        self.disparity = self._calculate_disparity()
Пример #21
0
    def __init__(self, cu_dict: Dict[str, ObjectifiedElement],
                 dependencies_list: List[DependenceItem],
                 loop_data: Dict[str, int], reduction_vars: List[Dict[str,
                                                                      str]]):
        self.g = nx.MultiDiGraph()
        self.reduction_vars = reduction_vars

        for id, node in cu_dict.items():
            n = parse_cu(node)
            if n.name == "main":
                self.main = n
            self.g.add_node(id, data=n)

        for node in self.all_nodes(NodeType.LOOP):
            node.loop_iterations = loop_data.get(node.start_position(), 0)

        for node_id, node in cu_dict.items():
            source = node_id
            if 'childrenNodes' in dir(node):
                for child in [n.text for n in node.childrenNodes]:
                    if child not in self.g:
                        print(f"WARNING: no child node {child} found")
                    self.g.add_edge(source,
                                    child,
                                    data=Dependency(EdgeType.CHILD))
            if 'successors' in dir(node) and 'CU' in dir(node.successors):
                for successor in [n.text for n in node.successors.CU]:
                    if successor not in self.g:
                        print(f"WARNING: no successor node {successor} found")
                    self.g.add_edge(source,
                                    successor,
                                    data=Dependency(EdgeType.SUCCESSOR))

        # calculate position before dependencies affect them
        try:
            self.pos = nx.planar_layout(self.g)  # good
        except nx.exception.NetworkXException:
            try:
                # fallback layouts
                self.pos = nx.shell_layout(self.g)  # maybe
                # self.pos = nx.kamada_kawai_layout(self.graph) # maybe
            except nx.exception.NetworkXException:
                self.pos = nx.random_layout(self.g)

        for dep in dependencies_list:
            if dep.type == 'INIT':
                continue

            sink_cu_ids = readlineToCUIdMap[dep.sink]
            source_cu_ids = writelineToCUIdMap[dep.source]
            for sink_cu_id in sink_cu_ids:
                for source_cu_id in source_cu_ids:
                    if sink_cu_id == source_cu_id and (dep.type == 'WAR'
                                                       or dep.type == 'WAW'):
                        continue
                    elif sink_cu_id and source_cu_id:
                        self.g.add_edge(sink_cu_id,
                                        source_cu_id,
                                        data=parse_dependency(dep))
Пример #22
0
    def show_dag(self, expand=set()):
        """Generate and show a DAG for the model
        """
        from matplotlib.pyplot import show as pltshow

        G = self.make_dag(expand=expand)

        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            ## Plotting
            edge_labels = dict([((
                u,
                v,
            ), d["label"]) for u, v, d in G.edges(data=True)])
            n = G.size()

            ## Manual layout
            # if n == 2:
            if False:
                pos = {
                    "(var)": [-0.5, +0.5],
                    "(out)": [+0.5, -0.5],
                }
                pos[self.functions[0].name] = [+0.5, +0.5]
            ## Optimized layout
            else:
                try:
                    ## Planar, if possible
                    pos = nx.planar_layout(G)
                except nx.NetworkXException:
                    ## Scaled spring layout
                    pos = nx.spring_layout(
                        G,
                        k=0.6 * n,
                        pos={
                            "(Inputs)": [-0.5 * n, +0.5 * n],
                            "(Outputs)": [+0.5 * n, -0.5 * n],
                        },
                        fixed=["(var)", "(out)"],
                        threshold=1e-6,
                        iterations=100,
                    )

            # Generate colormap
            color_map = []
            for node in G:
                if G.nodes[node]["parent"] == self.name:
                    color_map.append("blue")
                else:
                    color_map.append("green")

            # Draw
            nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
            nx.draw(G,
                    pos,
                    node_size=1000,
                    with_labels=True,
                    node_color=color_map)
            pltshow()
	def build_img(self):
		G = nx.from_sparse6_bytes(self.sparse6.encode('ascii'))
		try:
			node_dic = {k:tuple(v) for k,v in nx.planar_layout(G).items()}
		except nx.NetworkXException:
			node_dic = {k:tuple(v) for k,v in nx.circular_layout(G, scale=0.6).items()}
		self.image_dic = node_dic
		self.has_image = True
Пример #24
0
    def draw(self):
        labels = dict(self.nodes())
        for k in labels.keys():
            labels[k] = str(k.__class__.__name__) + " " + str(
                k.coord).split(":")[1]

        nx.draw_networkx(self, labels=labels, pos=nx.planar_layout(self))
        plt.show()
Пример #25
0
 def test_smoke_int(self):
     G = self.Gi
     nx.random_layout(G)
     nx.circular_layout(G)
     nx.planar_layout(G)
     nx.spring_layout(G)
     nx.fruchterman_reingold_layout(G)
     nx.fruchterman_reingold_layout(self.bigG)
     nx.spectral_layout(G)
     nx.spectral_layout(G.to_directed())
     nx.spectral_layout(self.bigG)
     nx.spectral_layout(self.bigG.to_directed())
     nx.shell_layout(G)
     nx.spiral_layout(G)
     nx.kamada_kawai_layout(G)
     nx.kamada_kawai_layout(G, dim=1)
     nx.kamada_kawai_layout(G, dim=3)
Пример #26
0
def draw_text_graph(G, labels):
    plt.figure(figsize=(18, 12))
    pos = nx.planar_layout(G, scale=18)
    nx.draw_networkx_nodes(G, pos, node_color="red", linewidths=0, node_size=500)
    nx.draw_networkx_labels(G, pos, font_size=20, labels=labels)
    nx.draw_networkx_edges(G, pos)
    plt.xticks([])
    plt.yticks([])
    plt.show()
Пример #27
0
def drawPlanarGraph(G, filename):
    posit = nx.planar_layout(G)

    fig = plt.figure()
    fig.show()

    nx.draw(G, posit, with_labels=True)
    fig.canvas.draw()
    plt.savefig(filename, format="PNG")
Пример #28
0
def MPG_network(n,z=0):
    G = sample_MPG(n)
    nodes = np.asanyarray(G.nodes())
    arcs = np.asanyarray(G.edges())
    pos = nx.planar_layout(G)
    posConv = {}
    for i in range(n):
        posConv[i] = (pos[i][0], pos[i][1], z)
    return nodes, arcs, posConv
Пример #29
0
def main():
    warnings.filterwarnings("ignore") #To ignore warning given by matplotlib
    G = ptpg.PTPG()
    G.add_nesw_vertices()
    G.node_position = nx.planar_layout(nx.from_numpy_matrix(G.matrix))
    draw_undirected_graph(G)
    x = input()
    G.initialize_degrees()
    G.initialize_good_vertices()
    v, u = G.contract()
    while v != -1:
        print("Contracted the edge between " + str(v) + " and " + str(u))
        node_position = nx.planar_layout(nx.from_numpy_matrix(G.matrix))
        draw_undirected_graph(G)
        x = input()
        v, u = G.contract()
        
    G.get_trivial_rel()
    draw_directed_graph(G)

    # REMOVE following 2 lines later
    construct_rdg(G)
    draw_rdg(G)

    while len(G.contractions) != 0:
        x = input()
        G.expand()
        draw_directed_graph(G)

        #REMOVE following 2 lines later
        construct_rdg(G)
        draw_rdg(G)

    # G.populate_t1_matrix()
    # print(G.t1_matrix)
    # G.populate_t2_matrix()
    # print(G.t2_matrix)
    # G.get_dimensions()
    # print(G.room_x)
    # print(G.room_y)
    # print(G.room_width)
    # print(G.room_height)
    construct_rdg(G)
    draw_rdg(G)
Пример #30
0
 def syncGraph(self):
     # graphs
     self.ui.widget__displayGraph.canvas.axes.clear()
     # Selecting a layout from self.selected_layout
     if self.selected_layout == 'Планарный вид':
         pos = nx.planar_layout(self.history_graphs[self.current_time])
     elif self.selected_layout == 'Декартова плоскость':
         pos = self.cartesian_coordinate_layout()
     elif self.selected_layout == 'Круговой вид':
         pos = nx.circular_layout(self.history_graphs[self.current_time])
     elif self.selected_layout == 'Вид оболочки':
         pos = nx.shell_layout(self.history_graphs[self.current_time])
     elif self.selected_layout == 'Фрюхтерман-Рейнгольд':
         pos = nx.spring_layout(self.history_graphs[self.current_time])
     # Edge labels
     edge_labels = {
         (u, v): round(d['weight'], DEFAULT_ROUND_DIGIT)
         for u, v, d in self.history_graphs[self.current_time].edges(
             data=True)
     }
     # And draw the graph
     nx.draw_networkx_nodes(
         self.history_graphs[self.current_time],
         pos=pos,
         nodelist=range(1, self.nodes_amount),
         node_color='#509bff',
         ax=self.ui.widget__displayGraph.canvas.axes,
     )
     nx.draw_networkx_nodes(
         self.history_graphs[self.current_time],
         pos=pos,
         nodelist=[0],
         node_color='#ff3b3f',
         ax=self.ui.widget__displayGraph.canvas.axes,
     )
     nx.draw_networkx_labels(
         self.history_graphs[self.current_time],
         pos=pos,
         ax=self.ui.widget__displayGraph.canvas.axes,
     )
     nx.draw_networkx_edges(
         self.history_graphs[self.current_time],
         pos=pos,
         alpha=0.8,
         ax=self.ui.widget__displayGraph.canvas.axes,
     )
     nx.draw_networkx_edge_labels(
         self.history_graphs[self.current_time],
         pos=pos,
         edge_labels=edge_labels,
         font_size=9,
         ax=self.ui.widget__displayGraph.canvas.axes,
     )
     #self.ui.widget__displayGraph.canvas.axes.axis('off')
     self.ui.widget__displayGraph.canvas.axes.figure.tight_layout()
     self.ui.widget__displayGraph.canvas.draw()