Merge pull request The-OpenROAD-Project#9280 from gadfort/gui-legend

gui: add separate classes for rendering legends

Author: maliberty

src/gui/include/gui/gui.h

@@ -651,6 +651,54 @@ class SpectrumGenerator
  private:
   static const unsigned char kSpectrum[256][3];
   double scale_;
+  static constexpr int kLegendColorIncrement = 2;
+};
+
+class Legend
+{
+ public:
+  virtual ~Legend() = default;
+
+  virtual void draw(Painter& painter) const = 0;
+
+ protected:
+  Legend() = default;
+};
+
+// A legend for a linear spectrum of colors
+// The colors are specified as continuous from low to high
+// For example, a heat map legend
+class LinearLegend : public Legend
+{
+ public:
+  LinearLegend(const std::vector<Painter::Color>& colors);
+
+  // Set the legend key as a vector of (color, text) pairs
+  void setLegendKey(
+      const std::vector<std::pair<Painter::Color, std::string>>& legend_key);
+
+  void draw(Painter& painter) const override;
+
+ private:
+  std::vector<Painter::Color> colors_;
+  std::vector<std::pair<Painter::Color, std::string>> legend_key_;
+};
+
+// A legend for discrete colors
+// Each color is associated with a text label
+// For example, a timing path legend
+class DiscreteLegend : public Legend
+{
+ public:
+  DiscreteLegend() = default;
+
+  // Add a (color, text) entry to the legend
+  void addLegendKey(const Painter::Color& color, const std::string& text);
+
+  void draw(Painter& painter) const override;
+
+ private:
+  std::vector<std::pair<Painter::Color, std::string>> color_key_;
 };
 
 // A chart with a single X axis and potentially multiple Y axes

src/gui/src/gui.cpp

@@ -1183,6 +1183,8 @@ void Renderer::setSettings(const Renderer::Settings& settings)
   }
 }
 
+//////////////////////////////////////////////////////////////////
+
 SpectrumGenerator::SpectrumGenerator(double max_value) : scale_(1.0 / max_value)
 {
 }
@@ -1209,6 +1211,40 @@ Painter::Color SpectrumGenerator::getColor(double value, int alpha) const
 void SpectrumGenerator::drawLegend(
     Painter& painter,
     const std::vector<std::pair<int, std::string>>& legend_key) const
+{
+  const int color_count = getColorCount();
+  std::vector<Painter::Color> colors;
+  colors.reserve(color_count);
+  for (int i = 0; i < color_count; i += kLegendColorIncrement) {
+    const double color_idx = (color_count - 1 - i) / scale_;
+    colors.push_back(getColor(color_idx / color_count));
+  }
+  std::vector<std::pair<Painter::Color, std::string>> legend_key_colors;
+  for (const auto& [legend_value, legend_text] : legend_key) {
+    const int idx = std::clamp(legend_value / kLegendColorIncrement,
+                               0,
+                               static_cast<int>(colors.size()) - 1);
+    legend_key_colors.push_back({colors[idx], legend_text});
+  }
+  LinearLegend legend(colors);
+  legend.setLegendKey(legend_key_colors);
+  legend.draw(painter);
+}
+
+/////////////////////////////////////////////////
+
+LinearLegend::LinearLegend(const std::vector<Painter::Color>& colors)
+    : colors_(colors)
+{
+}
+
+void LinearLegend::setLegendKey(
+    const std::vector<std::pair<Painter::Color, std::string>>& legend_key)
+{
+  legend_key_ = legend_key;
+}
+
+void LinearLegend::draw(Painter& painter) const
 {
   const odb::Rect& bounds = painter.getBounds();
   const double pixel_per_dbu = painter.getPixelsPerDBU();
@@ -1224,14 +1260,20 @@ void SpectrumGenerator::drawLegend(
   odb::Rect legend_bounds(
       legend_left, legend_top, legend_right + text_offset, legend_top);
 
-  const int color_count = getColorCount();
-  const int color_incr = 2;
+  const int color_count = colors_.size();
 
   std::vector<std::pair<odb::Point, std::string>> legend_key_points;
-  for (const auto& [legend_value, legend_text] : legend_key) {
+  for (const auto& [legend_color, legend_text] : legend_key_) {
+    const auto find_color = std::ranges::find(colors_, legend_color);
+    if (find_color == colors_.end()) {
+      continue;
+    }
+    const int legend_value
+        = std::distance(colors_.begin(), find_color);  // index in colors_
+
     const int text_right = legend_left - text_offset;
     const int box_top
-        = legend_top - ((color_count - legend_value) * box_height) / color_incr;
+        = legend_top - ((color_count - legend_value) * box_height);
 
     legend_key_points.push_back({{text_right, box_top}, legend_text});
     const odb::Rect text_bounds = painter.stringBoundaries(
@@ -1247,10 +1289,8 @@ void SpectrumGenerator::drawLegend(
 
   // draw color map
   double box_top = legend_top;
-  for (int i = 0; i < color_count; i += color_incr) {
-    const double color_idx = (color_count - 1 - i) / scale_;
-
-    painter.setPen(getColor(color_idx / color_count), true);
+  for (int i = 0; i < color_count; i++) {
+    painter.setPen(colors_[i], true);
     painter.drawLine(odb::Point(legend_left, box_top),
                      odb::Point(legend_right, box_top));
     box_top -= box_height;
@@ -1265,6 +1305,71 @@ void SpectrumGenerator::drawLegend(
   painter.drawRect(odb::Rect(legend_left, box_top, legend_right, legend_top));
 }
 
+/////////////////////////////////////////////////
+
+void DiscreteLegend::addLegendKey(const Painter::Color& color,
+                                  const std::string& text)
+{
+  color_key_.emplace_back(color, text);
+}
+
+void DiscreteLegend::draw(Painter& painter) const
+{
+  const odb::Rect& bounds = painter.getBounds();
+  const double pixel_per_dbu = painter.getPixelsPerDBU();
+  const int legend_offset = 20 / pixel_per_dbu;  // 20 pixels
+  const int legend_width = 20 / pixel_per_dbu;   // 20 pixels
+  const int text_offset = 2 / pixel_per_dbu;
+  const int color_offset = 2 * text_offset;
+  const int legend_top = bounds.yMax() - legend_offset;
+  const int legend_right = bounds.xMax() - legend_offset;
+  const int legend_left = legend_right - legend_width;
+
+  odb::Rect legend_bounds(
+      legend_left, legend_top, legend_right + text_offset, legend_top);
+
+  std::vector<std::pair<odb::Rect, std::string>> legend_key_rects;
+  std::vector<std::pair<odb::Rect, Painter::Color>> legend_color_rects;
+  int last_text_top = legend_top;
+  for (const auto& [legend_color, legend_text] : color_key_) {
+    const int text_right = legend_left - text_offset;
+
+    const odb::Rect key_rect = painter.stringBoundaries(
+        text_right, last_text_top, Painter::Anchor::kTopRight, legend_text);
+
+    last_text_top = key_rect.yMin();
+
+    legend_key_rects.push_back({key_rect, legend_text});
+    legend_color_rects.push_back({{legend_left + color_offset,
+                                   key_rect.yMin() + color_offset,
+                                   legend_right - color_offset,
+                                   key_rect.yMax() - color_offset},
+                                  legend_color});
+    legend_bounds.merge(key_rect);
+  }
+
+  // draw background
+  painter.setPen(Painter::kDarkGray, true);
+  painter.setBrush(Painter::kDarkGray);
+  painter.drawRect(legend_bounds, 10, 10);
+
+  // draw color map
+  painter.setPen(Painter::kBlack, true);
+  for (const auto& [rect, color] : legend_color_rects) {
+    painter.setBrush(color);
+    painter.drawRect(rect);
+  }
+
+  // draw key values
+  painter.setBrush(Painter::kTransparent);
+  for (const auto& [rect, text] : legend_key_rects) {
+    painter.drawString(
+        rect.xMax(), rect.yCenter(), Painter::Anchor::kRightCenter, text);
+  }
+}
+
+/////////////////////////////////////////////////
+
 void Gui::fit()
 {
   main_window->fit();

src/gui/src/staGui.cpp

@@ -485,6 +485,7 @@ TimingPathRenderer::TimingPathRenderer() : path_(nullptr)
   addDisplayControl(kDataPathLabel, true);
   addDisplayControl(kLaunchClockLabel, true);
   addDisplayControl(kCaptureClockLabel, true);
+  addDisplayControl(kLegendLabel, true);
 }
 
 void TimingPathRenderer::highlight(TimingPath* path)
@@ -607,6 +608,16 @@ void TimingPathRenderer::drawObjects(gui::Painter& painter)
                 checkDisplayControl(kDataPathLabel));
 
   highlightStage(painter, net_descriptor, inst_descriptor);
+
+  if (checkDisplayControl(kLegendLabel)) {
+    DiscreteLegend legend;
+    legend.addLegendKey(kCaptureClockColor, "Capture");
+    legend.addLegendKey(kClockColor, "Launch");
+    legend.addLegendKey(kSignalColor, "Signal");
+    legend.addLegendKey(kPathInstColor, "Inst");
+    legend.addLegendKey(kTermColor, "Term");
+    legend.draw(painter);
+  }
 }
 
 void TimingPathRenderer::highlightStage(gui::Painter& painter,

src/gui/src/staGui.h

@@ -246,6 +246,7 @@ class TimingPathRenderer : public gui::Renderer
   static constexpr const char* kDataPathLabel = "Data path";
   static constexpr const char* kLaunchClockLabel = "Launch clock";
   static constexpr const char* kCaptureClockLabel = "Capture clock";
+  static constexpr const char* kLegendLabel = "Legend";
 };
 
 class TimingConeRenderer : public gui::Renderer

src/gui/src/stub.cpp

@@ -98,6 +98,15 @@ SpectrumGenerator::SpectrumGenerator(double scale) : scale_(scale)
 {
 }
 
+void DiscreteLegend::addLegendKey(const Painter::Color& color,
+                                  const std::string& text)
+{
+}
+
+void DiscreteLegend::draw(Painter& painter) const
+{
+}
+
 bool Renderer::checkDisplayControl(const std::string& /* name */)
 {
   return false;

src/pad/src/RDLGui.cpp

@@ -50,9 +50,9 @@ void RDLGui::drawObjects(gui::Painter& painter)
   }
 
   const bool draw_obs = draw_detail && checkDisplayControl(kDrawObs);
+  gui::Painter::Color obs_color = gui::Painter::kCyan;
+  obs_color.a = 127;
   if (draw_obs) {
-    gui::Painter::Color obs_color = gui::Painter::kCyan;
-    obs_color.a = 127;
     painter.setPenAndBrush(obs_color, true);
 
     for (const auto& [rect, poly, ptr, src] : router_->getObstructions()) {
@@ -88,9 +88,9 @@ void RDLGui::drawObjects(gui::Painter& painter)
     }
   }
 
+  gui::Painter::Color edge_color = gui::Painter::kGreen;
+  edge_color.a = 127;
   if (draw_edge) {
-    gui::Painter::Color edge_color = gui::Painter::kGreen;
-    edge_color.a = 127;
     painter.setPenAndBrush(edge_color, true);
 
     for (const auto& v : vertex) {
@@ -215,6 +215,15 @@ void RDLGui::drawObjects(gui::Painter& painter)
   for (const auto& [pt0, pt1] : snap_) {
     painter.drawLine(pt0, pt1);
   }
+
+  gui::DiscreteLegend legend;
+  legend.addLegendKey(gui::Painter::kRed, "Vertex");
+  legend.addLegendKey(edge_color, "Edge");
+  legend.addLegendKey(obs_color, "Obstruction");
+  legend.addLegendKey(gui::Painter::kBlue, "Target");
+  legend.addLegendKey(gui::Painter::kYellow, "Flywire");
+  legend.addLegendKey(gui::Painter::kGreen, "Route");
+  legend.draw(painter);
 }
 
 void RDLGui::addSnap(const odb::Point& pt0, const odb::Point& pt1)

src/pdn/src/renderer.cpp

@@ -288,6 +288,15 @@ void PDNRenderer::drawLayer(odb::dbTechLayer* layer, gui::Painter& painter)
 
 void PDNRenderer::drawObjects(gui::Painter& painter)
 {
+  gui::DiscreteLegend legend;
+  legend.addLegendKey(ring_color_, "Ring");
+  legend.addLegendKey(strap_color_, "Strap");
+  legend.addLegendKey(followpin_color_, "Followpin");
+  legend.addLegendKey(via_color_, "Via");
+  legend.addLegendKey(obstruction_color_, "Obstruction");
+  legend.addLegendKey(repair_color_, "Repair Area");
+  legend.addLegendKey(repair_outline_color_, "Repair Area Outline");
+  legend.draw(painter);
 }
 
 void PDNRenderer::pause()

src/psm/src/debug_gui.cpp

@@ -611,6 +611,16 @@ void DebugGui::drawLayer(odb::dbTechLayer* layer, gui::Painter& painter)
       drawSource(*node_itr, painter);
     }
   }
+
+  gui::DiscreteLegend legend;
+  legend.addLegendKey(shape_color_, "Shape");
+  legend.addLegendKey(node_color_, "Node");
+  legend.addLegendKey(iterm_node_color_, "ITerm Node");
+  legend.addLegendKey(bpin_node_color_, "BPin Node");
+  legend.addLegendKey(connection_color_, "Connection");
+  legend.addLegendKey(term_connection_color_, "Terminal Connection");
+  legend.addLegendKey(src_node_color_, "Source Node/Shape");
+  legend.draw(painter);
 }
 
 gui::SelectionSet DebugGui::select(odb::dbTechLayer* layer,