Update app3.py

app3.py

@@ -27,7 +27,10 @@ for species, imgpath in species_to_imgpath.items():
 
 
 class Node():
+    id = 0
     def __init__(self, name):
+        self.id = Node.id
+        Node.id += 1
         self.name = name
         self.parent = None
         self.children = [] # list of type Node
@@ -37,6 +40,7 @@ class Node():
 
 
 name_to_node = {}
+id_to_node = {}
 
 def get_root(node):
     root = node
@@ -59,7 +63,7 @@ def get_tree(imgpath):
                 node = name_to_node[node_name]
             else:
                 node = Node(node_name)
-                name_to_node[node_name] = node
+                name_to_node[node_name] = id_to_node[node_name] = node
                 
             child_nodes = []
             for child_name in child_names:
@@ -67,7 +71,7 @@ def get_tree(imgpath):
                     child_node = name_to_node[child_name]
                 else:
                     child_node = Node(child_name)
-                    name_to_node[child_name] = child_node
+                    name_to_node[child_name] = id_to_node[node_name] = child_node
                 child_node.parent = node
                 child_nodes.append(child_node)
 
@@ -77,206 +81,98 @@ def get_tree(imgpath):
     return get_root(node)
                  
 
-# def display_tree():
-#     # This function should create and return a Plotly figure of the tree
-
-#     # Define the nodes and edges for the graph
-#     nodes = ['Node 1', 'Node 2', 'Node 3', 'Node 4']
-#     edges = [(0, 1), (0, 2), (2, 3)]  # Edges are tuples of node indices
-    
-#     # Define positions for the nodes (you can use a layout algorithm for more complex graphs)
-#     positions = [(0, 0), (1, 2), (1, -2), (2, 0)]
-    
-#     # Create traces for nodes and edges
-#     edge_x = []
-#     edge_y = []
-#     for edge in edges:
-#         x0, y0 = positions[edge[0]]
-#         x1, y1 = positions[edge[1]]
-#         edge_x.extend([x0, x1, None])
-#         edge_y.extend([y0, y1, None])
-    
-#     edge_trace = go.Scatter(
-#         x=edge_x, y=edge_y,
-#         line=dict(width=2, color='Black'),
-#         hoverinfo='none',
-#         mode='lines')
-    
-#     node_x = [pos[0] for pos in positions]
-#     node_y = [pos[1] for pos in positions]
-    
-#     node_trace = go.Scatter(
-#         x=node_x, y=node_y,
-#         mode='markers+text',
-#         hoverinfo='text',
-#         marker=dict(showscale=False, size=10, color='Goldenrod'),
-#         text=nodes,
-#         textposition="top center"
-#     )
-    
-#     # Define the layout of the graph
-#     layout = go.Layout(
-#         showlegend=False,
-#         hovermode='closest',
-#         margin=dict(b=0, l=0, r=0, t=0),
-#         xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-#         yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
-#     )
-    
-#     # Create the figure
-#     fig = go.Figure(data=[edge_trace, node_trace], layout=layout)
-#     return fig
 
 ROOT = None
 
 
-# def display_tree():
-#     nodes = []
-#     edges = []
-#     positions = {}
+def create_binary_tree_edges(root):
+    edges = []
+    prev = [root]
+    while len(prev) == 0:
+        new_prev = []
+        for node in prev:
+            edges += [(node.id, child.id) for child in node.children]
+            new_prev += [child for child in node.children if (len(child.children) > 0)]
+        prev = new_prev
 
-#     root = ROOT
-    
-#     def traverse(node, depth=0, index=0):
-
-#         if depth >= 3:
-#             return 
-            
-#         if node not in nodes:
-#             nodes.append(node)
-#         idx = nodes.index(node)
-#         positions[idx] = (depth * 1, index * 1 - len(nodes) / 2)  # Adjusted the multipliers for depth and index
-
-#         for child in node.children:
-#             if child not in nodes:
-#                 nodes.append(child)
-#             child_idx = nodes.index(child)
-#             edges.append((idx, child_idx))
-#             traverse(child, depth + 1, index + len(node.children) / 2)  # Recursively traverse to set positions
-
-#     traverse(root)
-    
-#     edge_x = []
-#     edge_y = []
-#     for edge in edges:
-#         x0, y0 = positions[edge[0]]
-#         x1, y1 = positions[edge[1]]
-#         edge_x.extend([x0, x1, None])
-#         edge_y.extend([y0, y1, None])
-    
-#     edge_trace = go.Scatter(
-#         x=edge_x, y=edge_y,
-#         line=dict(width=2, color='Black'),
-#         hoverinfo='none',
-#         mode='lines')
-    
-#     node_x = [pos[0] for pos in positions.values()]
-#     node_y = [pos[1] for pos in positions.values()]
-    
-#     node_trace = go.Scatter(
-#         x=node_x, y=node_y,
-#         mode='markers+text',
-#         hoverinfo='text',
-#         marker=dict(showscale=False, size=10, color='Goldenrod'),
-#         text=[node.name for node in nodes],
-#         textposition="top center"
-#     )
-    
-#     layout = go.Layout(
-#         title="Tree Visualization",
-#         showlegend=False,
-#         hovermode='closest',
-#         margin=dict(b=0, l=0, r=0, t=40),
-#         xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-#         yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
-#     )
-    
-#     fig = go.Figure(data=[edge_trace, node_trace], layout=layout)
-#     return fig
+def plot_tree_using_igraph():
+    # Define the edges in a tree structure
+    # edges = [(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)]
 
-
-
-
-
-def create_edge_list(node, edge_list=None, name_map=None):
-    if edge_list is None:
-        edge_list = []
-    if name_map is None:
-        name_map = {}
-    
-    if node.name not in name_map:
-        name_map[node.name] = len(name_map)
-    
-    for child in node.children:
-        if child.name not in name_map:
-            name_map[child.name] = len(name_map)
-        edge_list.append((name_map[node.name], name_map[child.name]))
-        create_edge_list(child, edge_list, name_map)
-    
-    return edge_list, list(name_map.keys())
-
-def display_tree():
     root = ROOT
-    edge_list, node_names = create_edge_list(root)
-    
-    # Create an igraph Graph from edge list
-    g = ig.Graph(edges=edge_list, directed=True)
-    
-    # Use the Reingold-Tilford tree layout
-    layout = g.layout('rt', root=[0])
-    
-    # Scale the layout to make the tree more compact
-    scale_factor = 0.2  # Adjust this factor as needed
-    layout_coords = [(coord[0] * scale_factor, coord[1] * scale_factor) for coord in layout.coords]
-    
-    x_coords = [coord[0] for coord in layout_coords]
-    y_coords = [-coord[1] for coord in layout_coords]  # invert y-axis for a top-down tree view
+    edges = create_binary_tree_edges(root)
+    # edges = [(str(n1), str(n2)) for (n1, n2) in edges]
+
+    print(edges)
+    
+    # Create an igraph Graph from the edge list
+    g = ig.Graph(edges, directed=True)
+    
+    # Validate the root index
+    if g.vcount() > 0:  # Check if the graph has any vertices
+        root_vertex_id = 0  # This assumes that vertex '0' is the root
+    else:
+        print("The graph has no vertices.")
+        return None
+
+    # Use the Reingold-Tilford layout to position the nodes
+    try:
+        layout = g.layout_reingold_tilford(root=None)  # Correct root specification
+    except Exception as e:
+        print(f"Error computing layout: {e}")
+        return None
+
+    # Edge traces
+    edge_x = []
+    edge_y = []
+    for edge in edges:
+        start_idx, end_idx = edge
+        x0, y0 = layout.coords[start_idx]
+        x1, y1 = layout.coords[end_idx]
+        edge_x.extend([x0, x1, None])
+        edge_y.extend([-y0, -y1, None])  # y values are inverted to make the tree top-down
 
-    # Create Plotly traces for nodes and edges
     edge_trace = go.Scatter(
-        x=[None],
-        y=[None],
-        line=dict(width=2, color='#888'),
+        x=edge_x, y=edge_y,
+        line=dict(width=0.5, color='#888'),
         hoverinfo='none',
-        mode='lines'
-    )
-    
-    for v1, v2 in g.get_edgelist():
-        x0, y0 = layout_coords[v1]
-        x1, y1 = layout_coords[v2]
-        # edge_trace['x'] += [x0, x1, None]
-        # edge_trace['y'] += [-y0, -y1, None]  # invert y-axis
+        mode='lines')
 
-        edge_trace['x'] += tuple(list(edge_trace['x']) + [x0, x1, None])
-        edge_trace['y'] += tuple(list(edge_trace['y']) + [-y0, -y1, None])  # invert y-axis
+    # Node traces
+    node_x = [pos[0] for pos in layout.coords]
+    node_y = [-pos[1] for pos in layout.coords]  # y values are inverted
 
     node_trace = go.Scatter(
-            x=x_coords, y=y_coords,
-            text=node_names,
-            mode='markers+text',
-            hoverinfo='text',
-            textposition='top center',
-            marker=dict(
-                showscale=False,
-                color='Blue',
-                size=10,
-                line_width=2),
-            textfont=dict(
-                size=12,  # Increase the font size as needed
-                color='Black'
-            )
-        )
+        x=node_x, y=node_y,
+        text=["Node {}".format(i) for i in range(len(layout.coords))],
+        mode='markers+text',
+        hoverinfo='text',
+        marker=dict(
+            showscale=False,
+            size=10,
+            color='LightSkyBlue'
+        ),
+        textposition="bottom center"
+    )
 
     # Create a Plotly figure
     fig = go.Figure(data=[edge_trace, node_trace],
                     layout=go.Layout(
+                        title='<b>Tree Layout with iGraph and Plotly</b>',
+                        titlefont_size=16,
                         showlegend=False,
                         hovermode='closest',
-                        margin=dict(b=0, l=0, r=0, t=0),
+                        margin=dict(b=0, l=0, r=0, t=50),
                         xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
                         yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                        title="Tree Visualization"
+                        # height=600,
+                        # width=600,
+                        annotations=[dict(
+                            showarrow=False,
+                            xref="paper", yref="paper",
+                            x=0.005, y=-0.002 )]
                     ))
+
     return fig
 
 
@@ -298,7 +194,7 @@ with gr.Blocks() as demo:
     print(ROOT.name)
     gr.Markdown("## Interactive Tree and Image Display")
     with gr.Row():
-        tree_output = gr.Plot(display_tree)  # Connect the function directly
+        tree_output = gr.Plot(plot_tree_using_igraph)  # Connect the function directly
     
     with gr.Row():
         with gr.Column():