reworked pin and edge drawing code

Author: SamuelHo10

vpr/src/draw/draw_basic.cpp

@@ -609,164 +609,142 @@ void draw_routed_net(ParentNetId net_id, ezgl::renderer* g) {
 //Draws the set of rr_nodes specified, using the colors set in draw_state
 void draw_partial_route(const std::vector<RRNodeId>& rr_nodes_to_draw, ezgl::renderer* g) {
     t_draw_state* draw_state = get_draw_state_vars();
-    t_draw_coords* draw_coords = get_draw_coords_vars();
     auto& device_ctx = g_vpr_ctx.device();
     const auto& rr_graph = device_ctx.rr_graph;
 
     // Draw Pins
-    for (RRNodeId inode : rr_nodes_to_draw) {
-        
+    for (size_t i = 1; i < rr_nodes_to_draw.size(); ++i) {
+        RRNodeId inode = rr_nodes_to_draw[i];
+        auto rr_type = rr_graph.node_type(inode);
         bool is_inode_inter_cluster = is_inter_cluster_node(rr_graph, inode);
+        int node_layer = rr_graph.node_layer(inode);
 
+        ezgl::color color = draw_state->draw_rr_node[inode].color;
 
-    }
+        // For 3D architectures, draw only visible layers
+        if (!draw_state->draw_layer_display[node_layer].visible) {
+            continue;
+        }
 
+        // Skip drawing sources and sinks
+        if (rr_type == e_rr_type::SINK || rr_type == e_rr_type::SOURCE){
+            continue;
+        }
+
+        // Draw intra-cluster nodes
+        if (!is_inode_inter_cluster) {
+            draw_rr_intrapin(inode, color, g);
+            continue;
+        }
+
+        // Draw IO Pins
+        if (rr_type == e_rr_type::OPIN || rr_type == e_rr_type::IPIN) {
+            draw_rr_pin(inode, color, g);
+            continue;
+        }
 
+        // Draw Channels
+        if (rr_type == e_rr_type::CHANY || rr_type == e_rr_type::CHANX) {
+            draw_rr_chan(inode, color, g);
+            continue;
+        }
+    }
 
     // Draw Edges
     for (size_t i = 1; i < rr_nodes_to_draw.size(); ++i) {
+
         RRNodeId inode = rr_nodes_to_draw[i];
         auto rr_type = rr_graph.node_type(inode);
+        bool is_inode_inter_cluster = is_inter_cluster_node(rr_graph, inode);
+        int current_node_layer = rr_graph.node_layer(inode);
 
         RRNodeId prev_node = rr_nodes_to_draw[i - 1];
         auto prev_type = rr_graph.node_type(RRNodeId(prev_node));
-
-        bool is_inode_inter_cluster = is_inter_cluster_node(rr_graph, inode);
         bool is_prev_node_inter_cluster = is_inter_cluster_node(rr_graph, prev_node);
-
-        int current_node_layer = rr_graph.node_layer(inode);
         int prev_node_layer = rr_graph.node_layer(prev_node);
+
         t_draw_layer_display edge_visibility = get_element_visibility_and_transparency(prev_node_layer, current_node_layer);
+        ezgl::color color = draw_state->draw_rr_node[inode].color;
 
-        //Don't draw node if the layer of the node is not set to visible on screen
-        if (!draw_state->draw_layer_display[current_node_layer].visible) {
+        // For 3D architectures, draw only visible layers
+        if (!draw_state->draw_layer_display[current_node_layer].visible || !edge_visibility.visible) {
             continue;
         }
 
-        ezgl::color color = draw_state->draw_rr_node[inode].color;
-
         // Skip drawing sources and sinks
-        if (rr_graph.node_type(inode) == e_rr_type::SINK || rr_graph.node_type(inode) == e_rr_type::SOURCE || rr_graph.node_type(prev_node) == e_rr_type::SINK || rr_graph.node_type(prev_node) == e_rr_type::SOURCE) {
+        if (rr_type == e_rr_type::SINK || rr_type == e_rr_type::SOURCE || prev_type == e_rr_type::SINK || prev_type == e_rr_type::SOURCE) {
             continue;
         }
 
-        if (!is_inode_inter_cluster && !is_prev_node_inter_cluster) {
-
-            auto blk_id_pin_id1 = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
-            auto blk_id_pin_id2 = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
-
-            ezgl::point2d p1 = draw_coords->get_absolute_pin_location(blk_id_pin_id1.first, blk_id_pin_id1.second);
-            ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id2.first, blk_id_pin_id2.second);
-
-            g->set_color(color, edge_visibility.alpha);
-            g->draw_line(p1, p2);
-            g->draw_text(p1, blk_id_pin_id1.second->parent_node->pb_type->name, 50, 0.5 * 20);
+        g->set_color(color, edge_visibility.alpha);
 
+        if (!is_inode_inter_cluster && !is_prev_node_inter_cluster) {
+            draw_intrapin_to_intrapin(inode, prev_node, g);
             continue;
         }
 
         if (!is_inode_inter_cluster || !is_prev_node_inter_cluster) {
-            bool swap = false;
-            if (!is_inode_inter_cluster && is_prev_node_inter_cluster) {
-                //Swap the nodes so that the inter-cluster node is always the current node
-                std::swap(inode, prev_node);
-                swap = true;
-            }
-
-            auto blk_id_pin_id = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
-            float x1, y1;
-            ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id.first, blk_id_pin_id.second);
-            
-
-            for (const e_side& pin_side : TOTAL_2D_SIDES) {
-                if (!rr_graph.is_node_on_specific_side(RRNodeId(inode), pin_side)) {
-                    continue;
-                }
-                draw_get_rr_pin_coords(inode, &x1, &y1, pin_side);
-                g->set_color(color, edge_visibility.alpha);
-                g->draw_line({x1, y1}, p2);
-            }
-
+            draw_intrapin_to_pin(inode, prev_node, g);
             continue;
-
         }
 
         auto iedge = find_edge(prev_node, inode);
         auto switch_type = rr_graph.edge_switch(RRNodeId(prev_node), iedge);
 
         switch (rr_type) {
-            case e_rr_type::OPIN: {
-                draw_rr_pin(inode, color, g);
-                break;
-            }
             case e_rr_type::IPIN: {
-                draw_rr_pin(inode, color, g);
-                if (edge_visibility.visible) {
-                    g->set_color(color, edge_visibility.alpha);
-                    if (rr_graph.node_type(prev_node) == e_rr_type::OPIN) {
-                        draw_pin_to_pin(prev_node, inode, g);
-                    } else {
-                        draw_pin_to_chan_edge(inode, prev_node, g);
-                    }
+                if (rr_graph.node_type(prev_node) == e_rr_type::OPIN) {
+                    draw_pin_to_pin(prev_node, inode, g);
+                } else {
+                    draw_pin_to_chan_edge(inode, prev_node, g);
                 }
                 break;
             }
             case e_rr_type::CHANX: {
-                draw_rr_chan(inode, color, g);
-                if (edge_visibility.visible) {
-                    g->set_color(color, edge_visibility.alpha);
-                    switch (prev_type) {
-                        case e_rr_type::CHANX: {
-                            draw_chanx_to_chanx_edge(prev_node, inode, switch_type, g);
-                            break;
-                        }
-                        case e_rr_type::CHANY: {
-                            draw_chanx_to_chany_edge(inode, prev_node, FROM_Y_TO_X, switch_type, g);
-                            break;
-                        }
-                        case e_rr_type::OPIN: {
-                            draw_pin_to_chan_edge(prev_node, inode, g);
-                            break;
-                        }
-                        default: {
-                            VPR_ERROR(VPR_ERROR_OTHER,
-                                      "Unexpected connection from an rr_node of type %d to one of type %d.\n",
-                                      prev_type, rr_type);
-                        }
+                switch (prev_type) {
+                    case e_rr_type::CHANX: {
+                        draw_chanx_to_chanx_edge(prev_node, inode, switch_type, g);
+                        break;
+                    }
+                    case e_rr_type::CHANY: {
+                        draw_chanx_to_chany_edge(inode, prev_node, FROM_Y_TO_X, switch_type, g);
+                        break;
+                    }
+                    case e_rr_type::OPIN: {
+                        draw_pin_to_chan_edge(prev_node, inode, g);
+                        break;
+                    }
+                    default: {
+                        VPR_ERROR(VPR_ERROR_OTHER,
+                                    "Unexpected connection from an rr_node of type %d to one of type %d.\n",
+                                    prev_type, rr_type);
                     }
                 }
-
                 break;
             }
             case e_rr_type::CHANY: {
-                draw_rr_chan(inode, color, g);
-
-                if (edge_visibility.visible) {
-                    g->set_color(color, edge_visibility.alpha);
-                    switch (prev_type) {
-                        case e_rr_type::CHANX: {
-                            draw_chanx_to_chany_edge(prev_node, inode,
-                                                     FROM_X_TO_Y, switch_type, g);
-                            break;
-                        }
-                        case e_rr_type::CHANY: {
-                            draw_chany_to_chany_edge(RRNodeId(prev_node), RRNodeId(inode),
-                                                     switch_type, g);
-                            break;
-                        }
-                        case e_rr_type::OPIN: {
-                            draw_pin_to_chan_edge(prev_node, inode, g);
+                switch (prev_type) {
+                    case e_rr_type::CHANX: {
+                        draw_chanx_to_chany_edge(prev_node, inode,
+                                                    FROM_X_TO_Y, switch_type, g);
+                        break;
+                    }
+                    case e_rr_type::CHANY: {
+                        draw_chany_to_chany_edge(RRNodeId(prev_node), RRNodeId(inode),
+                                                    switch_type, g);
+                        break;
+                    }
+                    case e_rr_type::OPIN: {
+                        draw_pin_to_chan_edge(prev_node, inode, g);
 
-                            break;
-                        }
-                        default: {
-                            VPR_ERROR(VPR_ERROR_OTHER,
-                                      "Unexpected connection from an rr_node of type %d to one of type %d.\n",
-                                      prev_type, rr_type);
-                        }
+                        break;
+                    }
+                    default: {
+                        VPR_ERROR(VPR_ERROR_OTHER,
+                                    "Unexpected connection from an rr_node of type %d to one of type %d.\n",
+                                    prev_type, rr_type);
                     }
                 }
-
                 break;
             }
             default: {

vpr/src/draw/draw_rr.cpp

@@ -513,6 +513,21 @@ void draw_rr_edges(RRNodeId inode, ezgl::renderer* g) {
     } /* End of for each edge loop */
 }
 
+void draw_rr_intrapin(RRNodeId inode, const ezgl::color& color, ezgl::renderer* g) {
+    t_draw_coords* draw_coords = get_draw_coords_vars();
+
+    auto blk_id_pin_id = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
+
+    ezgl::point2d p = draw_coords->get_absolute_pin_location(blk_id_pin_id.first, blk_id_pin_id.second);
+
+    int transparency_factor = get_rr_node_transparency(inode);
+
+    g->set_color(color, transparency_factor);
+    g->fill_rectangle(
+        {p.x - draw_coords->pin_size, p.y - draw_coords->pin_size},
+        {p.x + draw_coords->pin_size, p.y + draw_coords->pin_size});
+}
+
 /* Draws an IPIN or OPIN rr_node.  Note that the pin can appear on more    *
  * than one side of a clb.  Also note that this routine can change the     *
  * current color to BLACK.                                                 */

vpr/src/draw/draw_rr.h

@@ -27,6 +27,7 @@ void draw_rr_edges(RRNodeId from_node, ezgl::renderer* g);
 
 void draw_rr_chan(RRNodeId inode, const ezgl::color color, ezgl::renderer* g);
 
+void draw_rr_intrapin(RRNodeId inode, const ezgl::color& color, ezgl::renderer* g);
 /* Draws an IPIN or OPIN rr_node.  Note that the pin can appear on more
  * than one side of a clb.  Also note that this routine can change the
  * current color to BLACK. */

vpr/src/draw/draw_rr_edges.cpp

@@ -279,6 +279,43 @@ void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_e
     }
 }
 
+void draw_intrapin_to_intrapin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g) {
+
+    auto draw_coords = get_draw_coords_vars();
+
+    auto blk_id_pin_id1 = get_rr_node_cluster_blk_id_pb_graph_pin(inode);
+    auto blk_id_pin_id2 = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
+
+    ezgl::point2d p1 = draw_coords->get_absolute_pin_location(blk_id_pin_id1.first, blk_id_pin_id1.second);
+    ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id2.first, blk_id_pin_id2.second);
+
+    g->draw_line(p1, p2);
+}
+
+void draw_intrapin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g) {
+    auto draw_coords = get_draw_coords_vars();
+    const auto& rr_graph = g_vpr_ctx.device().rr_graph;
+
+    if (!is_inter_cluster_node(rr_graph, inode) && is_inter_cluster_node(rr_graph, prev_node)) {
+        //Swap the nodes so that the inter-cluster node is always the current node
+        std::swap(inode, prev_node);
+    }
+
+    auto blk_id_pin_id = get_rr_node_cluster_blk_id_pb_graph_pin(prev_node);
+    float x1, y1;
+    ezgl::point2d p2 = draw_coords->get_absolute_pin_location(blk_id_pin_id.first, blk_id_pin_id.second);
+    
+
+    for (const e_side& pin_side : TOTAL_2D_SIDES) {
+        if (!rr_graph.is_node_on_specific_side(RRNodeId(inode), pin_side)) {
+            continue;
+        }
+        draw_get_rr_pin_coords(inode, &x1, &y1, pin_side);
+        g->draw_line({x1, y1}, p2);
+    }
+
+}
+
 void draw_pin_to_pin(RRNodeId opin_node, RRNodeId ipin_node, ezgl::renderer* g) {
     /* This routine draws an edge from the opin rr node to the ipin rr node */
     const auto& device_ctx = g_vpr_ctx.device();

vpr/src/draw/draw_rr_edges.h

@@ -20,6 +20,8 @@
 void draw_chany_to_chany_edge(RRNodeId from_node, RRNodeId to_node, short switch_type, ezgl::renderer* g);
 void draw_chanx_to_chanx_edge(RRNodeId from_node, RRNodeId to_node, short switch_type, ezgl::renderer* g);
 void draw_chanx_to_chany_edge(RRNodeId chanx_node, RRNodeId chany_node, enum e_edge_dir edge_dir, short switch_type, ezgl::renderer* g);
+void draw_intrapin_to_pin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g);
+void draw_intrapin_to_intrapin(RRNodeId inode, RRNodeId prev_node, ezgl::renderer* g);
 void draw_pin_to_pin(RRNodeId opin, RRNodeId ipin, ezgl::renderer* g);
 void draw_pin_to_sink(RRNodeId ipin_node, RRNodeId sink_node, ezgl::renderer* g);
 void draw_source_to_pin(RRNodeId source_node, RRNodeId opin_node, ezgl::renderer* g);