Optimize rendering of text for timers. (#4724)

Previously the fitting of the text into the boxes for the timers took
too long. Root cause for this is a fairly complicated computation for
determining the width of a rendered text. This seems to be used inside
the method to elide text as well.
This PR replaces the QFontMetrics::elidedText and
QFontMetrics::horizontalAdvance by a simplified, less accurate method.
We compute a lookup table storing the rendered width of all ascii
characters. The width is computed as the sum of the width of all
characters in a string (plus a heuristic to obtain an upper bound of the
actual width). The method to elide text is is implemented on basis of
this simplified width calculation.
Compare #4626.

Author: danielfenner

src/OrbitGl/QtTextRenderer.cpp

@@ -7,6 +7,7 @@
 #include <GteVector.h>
 #include <absl/meta/type_traits.h>
 
+#include <QChar>
 #include <QColor>
 #include <QFont>
 #include <QFontDatabase>
@@ -18,6 +19,7 @@
 #include <algorithm>
 #include <cfloat>
 #include <cmath>
+#include <cstdint>
 #include <string>
 
 #include "Introspection/Introspection.h"
@@ -29,7 +31,19 @@ namespace orbit_gl {
 
 namespace {
 
-float GetYOffsetFromAlignment(QtTextRenderer::VAlign alignment, float height) {
+// Qt offers a QFontMetrics::horizontalAdvance to determine the width of a rendered string. This
+// method is fairly slow. For rendering the text in the timers we therefore use a different method:
+// We compute a lookup table storing the rendered width of all the characters and sum over all the
+// characters in a string (compare GetCharacterWidthLookup, GetStringWidthFast below). The result is
+// consistently a bit shorter than the correct result provided by QFontMetrics::horizontalAdvance.
+// Applying the heuristic below to the result from the lookup reliably yields a fairly tight upper
+// bound for the true width of the rendered string. Don't try to make sense of the formula - it is
+// just a line fitted to example data.
+[[nodiscard]] int MaximumHeuristic(int width, int length, uint32_t font_size) {
+  return 2 + (length * static_cast<int>(font_size)) / (12 * 14) + width;
+}
+
+[[nodiscard]] float GetYOffsetFromAlignment(QtTextRenderer::VAlign alignment, float height) {
   switch (alignment) {
     case QtTextRenderer::VAlign::Top:
       return 0.f;
@@ -47,7 +61,7 @@ float GetYOffsetFromAlignment(QtTextRenderer::VAlign alignment, float height) {
   }
 }
 
-float GetXOffsetFromAlignment(QtTextRenderer::HAlign alignment, float width) {
+[[nodiscard]] float GetXOffsetFromAlignment(QtTextRenderer::HAlign alignment, float width) {
   // kOffset is a hack to compensate for subtle differences in the placement of the rendered text
   // under Linux and Windows. Setting kOffset == 0 under Windows results in texts starting left of
   // the interval border for unknown reasons (also see https://github.com/google/orbit/issues/4627).
@@ -126,7 +140,7 @@ void QtTextRenderer::AddText(const char* text, float x, float y, float z, TextFo
   font.setPixelSize(formatting.font_size);
   QFontMetrics metrics(font);
   float y_offset = GetYOffsetFromAlignment(formatting.valign, height_entire_text);
-  const float single_line_height = GetStringHeight(".", formatting.font_size);
+  const float single_line_height = GetSingleLineStringHeight(formatting.font_size);
   QStringList lines = text_as_qstring.split("\n");
   float max_line_width = 0.f;
   for (const auto& line : lines) {
@@ -156,9 +170,13 @@ void QtTextRenderer::AddText(const char* text, float x, float y, float z, TextFo
 float QtTextRenderer::AddTextTrailingCharsPrioritized(const char* text, float x, float y, float z,
                                                       TextFormatting formatting,
                                                       size_t trailing_chars_length) {
-  ORBIT_SCOPE_FUNCTION;
-  QString text_as_qstring(text);
-  const size_t text_length = text_as_qstring.length();
+  // Early-out: If we can't fit a single char, there's no use to do all the expensive
+  // calculations below - this is a major bottleneck in some cases
+  if (formatting.max_size >= 0 && GetMinimumTextWidth(formatting.font_size) > formatting.max_size) {
+    return 0.f;
+  }
+
+  const size_t text_length = std::strlen(text);
   if (text_length == 0) {
     return 0.f;
   }
@@ -169,40 +187,44 @@ float QtTextRenderer::AddTextTrailingCharsPrioritized(const char* text, float x,
         text, trailing_chars_length);
     trailing_chars_length = text_length;
   }
-  // Early-out: If we can't fit a single char, there's no use to do all the expensive
-  // calculations below - this is a major bottleneck in some cases
-  if (formatting.max_size >= 0 && GetMinimumTextWidth(formatting.font_size) > formatting.max_size) {
-    return 0.f;
-  }
 
   const float max_width =
       formatting.max_size == -1.f ? FLT_MAX : viewport_->WorldToScreen({formatting.max_size, 0})[0];
+  const QString text_as_qstring(text);
+  const CharacterWidthLookup& lookup = GetCharacterWidthLookup(formatting.font_size);
   const QString trailing_text = text_as_qstring.right(trailing_chars_length);
-  const QString leading_text = text_as_qstring.left(text_length - trailing_chars_length);
-  QFont font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
-  font.setPixelSize(formatting.font_size);
-  QFontMetrics metrics(font);
-  const float trailing_text_width = GetStringWidth(trailing_text, formatting.font_size);
-  QString elided_text;
+  const float trailing_text_width = GetStringWidthFast(trailing_text, lookup, formatting.font_size);
+  // If the trailing text fits we (potentially) elide the leading text.
   if (trailing_text_width < max_width) {
-    elided_text = metrics.elidedText(leading_text, Qt::ElideRight,
-                                     static_cast<int>(max_width - trailing_text_width));
+    const QString leading_text = text_as_qstring.left(text_length - trailing_chars_length);
+    const QString elided_text =
+        ElideText(leading_text, static_cast<int>(max_width - trailing_text_width), lookup,
+                  formatting.font_size);
+    return AddFittingSingleLineText(elided_text + trailing_text, x, y, z, formatting, lookup);
   }
+  // If the trailing text doesn't fit we simply elide the entire text (the trailing text is not
+  // preserved in this case).
+  const QString elided_text =
+      ElideText(text_as_qstring, static_cast<int>(max_width), lookup, formatting.font_size);
   if (elided_text.isEmpty()) {
-    // We can't fit any elided string with the trailing characters preserved so we elide the entire
-    // string and accept that the trailing characters are truncated.
-    elided_text = metrics.elidedText(text_as_qstring, Qt::ElideRight, static_cast<int>(max_width));
-    if (elided_text.isEmpty()) {
-      return 0.f;
-    }
-    return AddFittingSingleLineText(elided_text, x, y, z, formatting);
+    return 0.f;
   }
-  return AddFittingSingleLineText(elided_text + trailing_text, x, y, z, formatting);
+  return AddFittingSingleLineText(elided_text, x, y, z, formatting, lookup);
 }
 
 float QtTextRenderer::GetStringWidth(const char* text, uint32_t font_size) {
   QString text_as_qstring(text);
-  QStringList lines = text_as_qstring.split("\n");
+  return GetStringWidth(text_as_qstring, font_size);
+}
+
+float QtTextRenderer::GetStringHeight(const char* text, uint32_t font_size) {
+  QString text_as_qstring(text);
+  int number_of_lines = text_as_qstring.count('\n') + 1;
+  return static_cast<float>(number_of_lines) * GetSingleLineStringHeight(font_size);
+}
+
+float QtTextRenderer::GetStringWidth(const QString& text, uint32_t font_size) {
+  QStringList lines = text.split("\n");
   float max_width = 0.f;
   QFont font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
   font.setPixelSize(static_cast<int>(font_size));
@@ -214,38 +236,87 @@ float QtTextRenderer::GetStringWidth(const char* text, uint32_t font_size) {
   return max_width;
 }
 
-float QtTextRenderer::GetStringHeight(const char* text, uint32_t font_size) {
-  QString text_as_qstring(text);
-  QStringList lines = text_as_qstring.split("\n");
-  const float number_of_lines = lines.size();
-  QFont font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
-  font.setPixelSize(static_cast<int>(font_size));
-  QFontMetrics metrics(font);
-  return number_of_lines * viewport_->ScreenToWorld(Vec2i(0, metrics.height()))[1];
-}
-
-float QtTextRenderer::GetStringWidth(const QString& text, uint32_t font_size) {
-  std::string text_as_string = text.toStdString();
-  return GetStringWidth(text_as_string.c_str(), font_size);
-}
-
 float QtTextRenderer::GetMinimumTextWidth(uint32_t font_size) {
   auto minimum_string_width_it = minimum_string_width_cache_.find(font_size);
   if (minimum_string_width_it != minimum_string_width_cache_.end()) {
     return minimum_string_width_it->second;
   }
-  // Only if we can fit one wide (hence the "W") character plus the ellipsis dots we start rendering
-  // text. Otherwise we leave the space empty.
-  constexpr char const* kMinimumString = "W...";
+  // Only if we can fit one wide (hence the "W") character we start rendering text. Otherwise we
+  // leave the space empty.
+  constexpr char const* kMinimumString = "W";
   const float width = GetStringWidth(kMinimumString, font_size);
   minimum_string_width_cache_[font_size] = width;
   return width;
 }
 
+float QtTextRenderer::GetSingleLineStringHeight(uint32_t font_size) {
+  int metrics_height = 0;
+  auto it = single_line_height_cache_.find(font_size);
+  if (it == single_line_height_cache_.end()) {
+    QFont font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
+    font.setPixelSize(static_cast<int>(font_size));
+    QFontMetrics metrics(font);
+    int height = metrics.height();
+    metrics_height = single_line_height_cache_[font_size] = height;
+  } else {
+    metrics_height = it->second;
+  }
+  return viewport_->ScreenToWorld(Vec2i(0, metrics_height))[1];
+}
+
+const QtTextRenderer::CharacterWidthLookup& QtTextRenderer::GetCharacterWidthLookup(
+    uint32_t font_size) {
+  auto it = character_width_lookup_cache_.find(font_size);
+  if (it == character_width_lookup_cache_.end()) {
+    QFont font = QFontDatabase::systemFont(QFontDatabase::GeneralFont);
+    font.setPixelSize(static_cast<int>(font_size));
+    QFontMetrics metrics(font);
+    CharacterWidthLookup lut;
+    for (int i = 0; i < 256; i++) {
+      lut[i] = metrics.horizontalAdvance(QChar(i));
+    }
+    it = character_width_lookup_cache_.emplace(font_size, lut).first;
+  }
+  return it->second;
+}
+
+float QtTextRenderer::GetStringWidthFast(const QString& text, const CharacterWidthLookup& lookup,
+                                         uint32_t font_size) {
+  int width = 0;
+  for (const QChar& c : text) {
+    width += lookup[c.toLatin1()];
+  }
+  const int horizontal_advance = MaximumHeuristic(width, text.length(), font_size);
+  return viewport_->ScreenToWorld(Vec2i(horizontal_advance, 0))[0];
+}
+
+QString QtTextRenderer::ElideText(const QString& text, int max_width,
+                                  const CharacterWidthLookup& lookup, uint32_t font_size) {
+  int width_lookup = 0;
+  int characters = 0;
+  while (characters < text.length()) {
+    const int next_char_width = lookup[text[characters].toLatin1()];
+    if (MaximumHeuristic(width_lookup + next_char_width, characters, font_size) > max_width) {
+      break;
+    }
+    width_lookup += next_char_width;
+    characters++;
+  }
+  if (characters == text.length()) {
+    return text;
+  }
+  QString result = text.left(characters);
+  if (characters > 0) {
+    result[characters - 1] = ' ';
+  }
+  return result;
+}
+
 float QtTextRenderer::AddFittingSingleLineText(const QString& text, float x, float y, float z,
-                                               TextFormatting formatting) {
-  const float width = GetStringWidth(text, formatting.font_size);
-  const float single_line_height = GetStringHeight(".", formatting.font_size);
+                                               const TextFormatting& formatting,
+                                               const CharacterWidthLookup& lookup) {
+  const float width = GetStringWidthFast(text, lookup, formatting.font_size);
+  const float single_line_height = GetSingleLineStringHeight(formatting.font_size);
   Vec2i pen_pos = viewport_->WorldToScreen(Vec2(x, y));
   LayeredVec2 transformed = translations_.TranslateXYZAndFloorXY(
       {{static_cast<float>(pen_pos[0]), static_cast<float>(pen_pos[1])}, z});

src/OrbitGl/include/OrbitGl/MockTextRenderer.h

@@ -11,6 +11,7 @@
 
 #include <QPainter>
 #include <algorithm>
+#include <cstdint>
 #include <set>
 #include <vector>
 
@@ -42,6 +43,8 @@ class MockTextRenderer : public TextRenderer {
   [[nodiscard]] float GetStringWidth(const char* text, uint32_t font_size) override;
   [[nodiscard]] float GetStringHeight(const char* text, uint32_t font_size) override;
 
+  [[nodiscard]] float GetMinimumTextWidth(uint32_t /*font_size*/) override { return 0.f; };
+
   [[nodiscard]] bool HasAddTextsSameLength() const {
     return num_characters_in_add_text_.size() <= 1;
   }

src/OrbitGl/include/OrbitGl/QtTextRenderer.h

@@ -39,13 +39,21 @@ class QtTextRenderer : public TextRenderer {
 
   [[nodiscard]] float GetStringWidth(const char* text, uint32_t font_size) override;
   [[nodiscard]] float GetStringHeight(const char* text, uint32_t font_size) override;
+  [[nodiscard]] float GetMinimumTextWidth(uint32_t font_size) override;
 
  private:
+  using CharacterWidthLookup = std::array<int, 256>;
+
   [[nodiscard]] float GetStringWidth(const QString& text, uint32_t font_size);
-  [[nodiscard]] float GetMinimumTextWidth(uint32_t font_size);
+  [[nodiscard]] float GetSingleLineStringHeight(uint32_t font_size);
+  [[nodiscard]] const CharacterWidthLookup& GetCharacterWidthLookup(uint32_t font_size);
+  [[nodiscard]] float GetStringWidthFast(const QString& text, const CharacterWidthLookup& lookup,
+                                         uint32_t font_size);
+  [[nodiscard]] static QString ElideText(const QString& text, int max_width,
+                                         const CharacterWidthLookup& lookup, uint32_t font_size);
   [[nodiscard]] float AddFittingSingleLineText(const QString& text, float x, float y, float z,
-                                               TextFormatting formatting);
-
+                                               const TextFormatting& formatting,
+                                               const CharacterWidthLookup& lookup);
   struct StoredText {
     StoredText() = default;
     StoredText(const QString& text, int x, int y, int w, int h, TextFormatting formatting)
@@ -59,6 +67,8 @@ class QtTextRenderer : public TextRenderer {
   };
   absl::flat_hash_map<float, std::vector<StoredText>> stored_text_;
   absl::flat_hash_map<uint32_t, float> minimum_string_width_cache_;
+  absl::flat_hash_map<uint32_t, CharacterWidthLookup> character_width_lookup_cache_;
+  absl::flat_hash_map<uint32_t, int> single_line_height_cache_;
 };
 
 }  // namespace orbit_gl

src/OrbitGl/include/OrbitGl/TextRendererInterface.h

@@ -38,6 +38,7 @@ class TextRendererInterface {
 
   // Add a - potentially multiline - text at the given position and z-layer and with the specifier
   // formatting. If formatting.max_size is set all lines are elided to fit into this width.
+  // It is allowed for `text` to contain unicode characters.
   virtual void AddText(const char* text, float x, float y, float z, TextFormatting formatting) = 0;
   virtual void AddText(const char* text, float x, float y, float z, TextFormatting formatting,
                        Vec2* out_text_pos, Vec2* out_text_size) = 0;
@@ -46,13 +47,20 @@ class TextRendererInterface {
   // The renderer will shorten the text if the width exceeds formatting.max_size. The shortening
   // will happen in a way that tries to preserve the given numnber of trailing characters.
   // This is mainly used to preserve the duration in the text of time intervals. E.g. something like
-  // "MyVeryLongButNotSoImportantMethodName 2.35 ms" will render as "MyVery...2.35 ms".
+  // "MyVeryLongButNotSoImportantMethodName 2.35 ms" will render as "MyVery 2.35 ms".
+  // `text` must not contain unicode characters - this method is ascii only. The reason for that is
+  // that this allows for a much quicker heuristic for shortening strings as described above.
   virtual float AddTextTrailingCharsPrioritized(const char* text, float x, float y, float z,
                                                 TextFormatting formatting,
                                                 size_t trailing_chars_length) = 0;
 
+  // Return the width and height of `text` in world coordinates. The text might contain line breaks
+  // and unicode characters.
   [[nodiscard]] virtual float GetStringWidth(const char* text, uint32_t font_size) = 0;
   [[nodiscard]] virtual float GetStringHeight(const char* text, uint32_t font_size) = 0;
+
+  // Returns the width of a minimum single character of given font size.
+  [[nodiscard]] virtual float GetMinimumTextWidth(uint32_t font_size) = 0;
 };
 
 }  // namespace orbit_gl

src/OrbitGl/include/OrbitGl/TimerTrack.h

@@ -9,6 +9,7 @@
 #include <stdint.h>
 
 #include <atomic>
+#include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
@@ -166,7 +167,9 @@ class TimerTrack : public Track {
 
   [[nodiscard]] inline bool BoxHasRoomForText(orbit_gl::TextRenderer& text_renderer,
                                               const float width) {
-    return text_renderer.GetStringWidth("w", layout_->GetFontSize()) < width;
+    const uint32_t font_size = layout_->GetFontSize();
+    const float width_of_single_char = text_renderer.GetMinimumTextWidth(font_size);
+    return width_of_single_char < width;
   }
 
   [[nodiscard]] bool ShouldHaveBorder(
@@ -180,6 +183,7 @@ class TimerTrack : public Track {
   OrbitApp* app_ = nullptr;
 
   orbit_client_data::TimerData* timer_data_;
+  absl::flat_hash_map<uint32_t, float> width_of_single_char_cache_;
 };
 
 #endif  // ORBIT_GL_TIMER_TRACK_H_