GPU Display Qt GUI: Add proper passing of frames with config elements to the GUI and returning lambda functions with value updates

Author: davidrohr

GPU/GPUTracking/Definitions/GPUSettingsList.h

@@ -456,8 +456,8 @@ AddOption(propagateTracks, int32_t, 0, "", 0, "Propagate final tracks further (i
 AddOption(showCollision, int32_t, -1, "", 0, "Show only individual collision")
 AddOption(colorCollisions, int32_t, 0, "", 0, "Distinguish collisions in timeframe by color")
 AddOption(colorClusters, int32_t, 1, "", 0, "Color clusters belonging to track objects")
-AddOption(pointSize, float, 2.0f, "", 0, "Set point size")
-AddOption(lineWidth, float, 1.4f, "", 0, "Set line width")
+AddOption(pointSize, float, 2.0f, "", 0, "Set point size", min(0.8f), max(20.f))
+AddOption(lineWidth, float, 1.4f, "", 0, "Set line width", min(0.4f), max(20.f))
 AddOption(drawTPC, bool, true, "", 0, "Enable drawing TPC data")
 AddOption(drawTRD, bool, true, "", 0, "Enabale drawing TRD data")
 AddOption(drawTOF, bool, true, "", 0, "Enabale drawing TOF data")
@@ -502,11 +502,11 @@ AddOption(camYUp, bool, false, "", 0, "Orient the camera such that the y-axis is
 AddOption(cameraMode, int32_t, 0, "", 0, "Camera mode")
 AddOption(fullScreen, bool, false, "", 0, "Full Screen")
 AddOption(maximized, bool, true, "", 0, "Maximized window")
-AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing")
-AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing")
+AddOption(drawQualityMSAA, int32_t, 0, "", 0, "MultiSample Anti Aliasing", min(0), max(8))
+AddOption(drawQualityDownsampleFSAA, int32_t, 0, "", 0, "Downsampling Anti Aliasing", min(0), max(4))
 AddOption(drawQualityVSync, bool, true, "", 0, "Enable Vertical Sync")
 AddOption(fpsLimit, int32_t, 1, "", 0, "FPS limit: 0 = none (maximum rate), 1 = display refresh rate (no limit without VSync), 2 = fpsRate")
-AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) for fpsLimit 2, or if the backend cannot limit to the refresh rate (0 = no limit)")
+AddOption(fpsRate, int32_t, 100, "", 0, "Target frame rate (frames per second) for fpsLimit 2, or if the backend cannot limit to the refresh rate", min(1), max(9999))
 AddOption(useGLIndirectDraw, bool, true, "", 0, "Use OpenGL indirect draws to reduce number of draw calls")
 AddOption(screenshotScaleFactor, int32_t, 1, "", 0, "Resolution scale factor when taking screenshots")
 AddOption(fov, int32_t, 45, "", 0, "Display FOV")

GPU/GPUTracking/display/GPUDisplay.cxx

@@ -244,8 +244,8 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(bool suspended, float animateTim
   mFrontend->mMouseWheel = 0;
   bool lookOrigin = mCfgR.camLookOrigin ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIGIN]];
   bool yUp = mCfgR.camYUp ^ mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_FOCUS_ORIENT_UP]] ^ lookOrigin;
-  bool rotateModel = mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]] || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
-  bool rotateModelTPC = mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
+  bool rotateModelTPC = mCfgC.mRotateAroundZ || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_AROUND_Z]];
+  bool rotateModel = rotateModelTPC || mCfgC.mRotateModel || mFrontend->mKeys[mFrontend->mKeyDownMap[mFrontend->KEY_MAP_ROTATE_MODEL]];
 
   // Calculate rotation / translation scaling factors
   float scalefactor = mFrontend->mKeys[mFrontend->KEY_SHIFT] ? 0.2f : 1.0f;

GPU/GPUTracking/display/GPUDisplay.h

@@ -95,13 +95,18 @@ class GPUDisplay : public GPUDisplayInterface
     bool mRequestScreenshot = false;
     int32_t mAnimateScreenshot = 0;
     bool mAnimationChangeConfig = true;
-    bool dummy = false; // dummy value to reference for keys that do not change variables
+    bool mGuiPrintInfo = false;  // Show the info of options changed with Qt GUI elements (not for key presses in the GUI)
+    bool mRotateModel = false;   // Rotate the model instead of the camera, like holding RCTRL (set in the Qt GUI)
+    bool mRotateAroundZ = false; // Rotate the TPC around the beamline, like holding RALT (set in the Qt GUI)
+    float mGuiScale = 1.f;       // Scale factor of text and elements of the Qt GUI (on top of the system scaling), Ctrl + mouse wheel / Ctrl + 0 in the GUI
+    bool dummy = false;          // dummy value to reference for keys that do not change variables
   } mCfgC;
 
  private:
   void buildConfig();
   void buildConfigKeys();
   void buildConfigInfo();
+  void buildConfigQtGUI();
 
   static constexpr int32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx

@@ -123,15 +123,19 @@ void GPUDisplayFrontend::HandleExternalGUISignals()
     for (int32_t key : update->keys) {
       mDisplay->HandleExternalGUIKey(key);
     }
-    if (update->lineWidth) {
-      mDisplay->mCfgL.lineWidth = *update->lineWidth;
+    applyGUIValues(update->values);
+    if (update->guiScale) {
+      mDisplay->mCfgC.mGuiScale = *update->guiScale;
     }
   }
 
   if (gui) {
+    auto values = getGUIValues();
     {
       std::lock_guard lock(mGUIChannel->mutex);
       mGUIChannel->state.cfg = {mDisplay->mCfgH, mDisplay->mCfgL, mDisplay->mCfgR};
+      mGUIChannel->state.values = std::move(values);
+      mGUIChannel->state.guiScale = mDisplay->mCfgC.mGuiScale;
       if (update) {
         mGUIChannel->state.appliedUpdate = update->id;
       }
@@ -205,6 +209,7 @@ int32_t GPUDisplayFrontend::startGUI()
       mGUIChannel->replyTimeout = std::chrono::milliseconds(mDisplay->cfg().guiReplyTimeout);
       mGUIChannel->maxUpdatesAhead = std::max<uint32_t>(mDisplay->cfg().guiMaxUpdatesAhead, 1); // 0 would block all updates
       mGUIChannel->windowName = DISPLAY_WINDOW_NAME;
+      setGUILayout(*mGUIChannel);
     }
     mGUI->start();
   } else {

GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h

@@ -22,10 +22,13 @@
 #include <mutex>
 #include <condition_variable>
 #include <string>
+#include <utility>
+#include <variant>
 #include <vector>
 
 namespace o2::gpu
 {
+using GPUDisplayGUIValue = std::variant<int64_t, double, std::string>; // Value of a Qt GUI element
 class GPUReconstruction;
 class GPUDisplay;
 class GPUDisplayBackend;
@@ -158,6 +161,11 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
   bool mWindowFullScreen = false, mWindowMaximized = false; // Window state last requested or reported by the window system
   template <typename... Args>
   void add_key_binding(Args&&... args); // KEY_LAMBDA(key, ...) entries, the help text, and optionally the keys to show in the help text, only used in GPUDisplayFrontendConfig.cxx
+  template <typename... Args>
+  void add_gui_binding(Args&&... args);                                                    // GUI_LAMBDA(name, ...) entries shown in one frame of the Qt GUI, and optionally its description and a flag to place the elements horizontally (default vertically), only used in GPUDisplayFrontendConfig.cxx
+  void setGUILayout(GPUDisplayGUIChannel& channel) const;                                  // Copy the GUI elements of the add_gui_binding calls to the channel
+  std::vector<GPUDisplayGUIValue> getGUIValues();                                          // Current values of the options of the GUI elements, by element id
+  void applyGUIValues(const std::vector<std::pair<uint32_t, GPUDisplayGUIValue>>& values); // Call the setter of the GUI elements changed in the GUI (element id, value), and show the info of their options
   void listConfig();
   const std::vector<std::string>& getHelpText() const; // Help text of all key bindings, one line per binding
 };

GPU/GPUTracking/display/frontend/GPUDisplayFrontendConfig.cxx

@@ -16,6 +16,7 @@
 #include "GPUDisplay.h"
 #include "frontend/GPUDisplayInfo.inc"
 #include "GPULogging.h"
+#include "GPUDisplayGUIChannel.h"
 #include "utils/qconfig_rtti.h"
 #include "utils/qconfig_internal_helpers.h"
 
@@ -31,6 +32,7 @@
 #include <string_view>
 #include <tuple>
 #include <utility>
+#include <variant>
 
 using namespace o2::gpu;
 struct GPUDisplayFrontend::configRTTIExt : public qConfig::qConfigRTTIentry {
@@ -57,6 +59,13 @@ struct GPUDisplayFrontend::configRTTIInfo {
   std::vector<std::string> keyMapNames;                             // Names of the key down mapping ids (KEY_MAP_*)
   std::vector<std::pair<std::string, std::string>> helpTextEntries; // Keys and text of each add_key_binding call
   std::vector<std::string> helpText;
+  struct guiElementCallbacks {
+    uint32_t rttiIndex;
+    std::function<void(const GPUDisplayGUIValue&)> set; // GUI_LAMBDA setter, applies a value from the GUI
+    std::function<GPUDisplayGUIValue()> get;            // Current value of the option of the element
+  };
+  std::vector<guiElementCallbacks> guiElements;                                                                               // By element id
+  std::vector<GPUDisplayGUIChannel::Frame> guiLayout;                                                                         // Frames of the add_gui_binding calls
   static constexpr std::string_view possibleKeys = " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ#.:;>'^_"; // Bindable keys >= 32 (space), special keys < 32 are those with a name in keyNames
 
   template <class T, size_t I = 0>
@@ -232,6 +241,148 @@ void GPUDisplayFrontend::add_key_binding(Args&&... args)
   mConfigRTTI->helpTextEntries.emplace_back(std::move(keys), std::get<nKeys>(argTuple));
 }
 
+struct guiType { // Element type and choices, GUI_CHECKBOX, GUI_DROPDOWN(...), etc. in GPUDisplayFrontendConfigQtGUI.inc
+  guiType(GPUDisplayGUIChannel::ElementType t, std::vector<std::pair<std::string, GPUDisplayGUIValue>> c = {}) : type(t), choices(std::move(c)) {}
+  GPUDisplayGUIChannel::ElementType type;
+  std::vector<std::pair<std::string, GPUDisplayGUIValue>> choices;
+};
+
+static std::vector<std::pair<std::string, GPUDisplayGUIValue>> guiSliderValues(std::initializer_list<GPUDisplayGUIValue> values) // Choices of GUI_SLIDER_VALUES, named by their value
+{
+  auto name = [](const auto& x) -> std::string {
+    if constexpr (std::is_same_v<std::remove_cvref_t<decltype(x)>, std::string>) {
+      return x;
+    } else {
+      return qConfig::print_type(x);
+    }
+  };
+  std::vector<std::pair<std::string, GPUDisplayGUIValue>> retVal;
+  for (const auto& v : values) {
+    retVal.emplace_back(std::visit(name, v), v);
+  }
+  return retVal;
+}
+
+struct guiElement { // GUI_LAMBDA(...)
+  guiElement(std::string n, uint32_t i, guiType t, std::function<void(const GPUDisplayGUIValue&)> s, std::function<GPUDisplayGUIValue()> g) : name(std::move(n)), rttiIndex(i), type(std::move(t)), set(std::move(s)), get(std::move(g)) {}
+  std::string name;
+  uint32_t rttiIndex;
+  guiType type;
+  std::function<void(const GPUDisplayGUIValue&)> set;
+  std::function<GPUDisplayGUIValue()> get;
+};
+
+template <class T>
+static void guiAssign(T& dst, const GPUDisplayGUIValue& value) // Default GUI_LAMBDA setter: assign the GUI value, converted to the type of the option
+{
+  std::visit([&](const auto& v) {
+    using V = std::remove_cvref_t<decltype(v)>;
+    if constexpr (std::is_same_v<T, std::string>) {
+      if constexpr (std::is_same_v<V, std::string>) {
+        dst = v;
+      } else {
+        dst = std::to_string(v);
+      }
+    } else if constexpr (std::is_same_v<V, std::string>) {
+      dst = static_cast<T>(std::stod(v)); // Throws for invalid text
+    } else {
+      dst = static_cast<T>(v);
+    }
+  },
+             value);
+}
+
+template <class T>
+static GPUDisplayGUIValue toGUIValue(const T& v)
+{
+  if constexpr (requires { v.load(); }) { // std::atomic in GPUDisplay::control
+    return toGUIValue(v.load());
+  } else if constexpr (std::is_same_v<T, std::string>) {
+    return v;
+  } else if constexpr (std::is_integral_v<T>) {
+    return (int64_t)v;
+  } else {
+    static_assert(std::is_floating_point_v<T>, "Unsupported option type for the Qt GUI");
+    return (double)v;
+  }
+}
+
+template <typename... Args>
+void GPUDisplayFrontend::add_gui_binding(Args&&... args)
+{
+  constexpr size_t nElements = (0 + ... + std::is_same_v<std::remove_cvref_t<Args>, guiElement>);
+  constexpr size_t nHorizontal = (0 + ... + std::is_same_v<std::remove_cvref_t<Args>, bool>);
+  static_assert(nElements >= 1 && nHorizontal <= 1 && sizeof...(Args) <= nElements + nHorizontal + 1, "add_gui_binding needs at least one GUI element, and optionally the description and the horizontal flag");
+  GPUDisplayGUIChannel::Frame frame;
+  auto addElement = [&](auto& element) {
+    using Type = GPUDisplayGUIChannel::ElementType;
+    const uint32_t id = mConfigRTTI->guiElements.size();
+    auto& el = frame.elements.emplace_back(GPUDisplayGUIChannel::Element{.name = element.name, .rttiIndex = element.rttiIndex, .type = element.type.type, .id = id, .isInteger = std::holds_alternative<int64_t>(element.get()), .choices = std::move(element.type.choices)});
+    if (el.type == Type::SLIDER) {
+      if (element.rttiIndex >= mConfigRTTI->rttiEntries.size()) {
+        throw std::runtime_error("GUI slider " + element.name + " needs an option with RTTI for min and max values");
+      }
+      const auto& e = mConfigRTTI->rttiEntries[element.rttiIndex];
+      if (e.min.empty() || e.max.empty()) {
+        throw std::runtime_error("GUI slider " + element.name + ": option " + e.name + " needs min and max values");
+      }
+      el.min = std::stod(e.min);
+      el.max = std::stod(e.max);
+    }
+    if (el.type == Type::TEXTBOX && element.rttiIndex < mConfigRTTI->rttiEntries.size() && !mConfigRTTI->rttiEntries[element.rttiIndex].min.empty() && !mConfigRTTI->rttiEntries[element.rttiIndex].max.empty()) {
+      el.min = std::stod(mConfigRTTI->rttiEntries[element.rttiIndex].min);
+      el.max = std::stod(mConfigRTTI->rttiEntries[element.rttiIndex].max);
+      el.hasRange = true;
+    }
+    if ((el.type == Type::RADIO_BUTTONS || el.type == Type::DROPDOWN) ? el.choices.empty() : (!el.choices.empty() && el.type != Type::SLIDER)) {
+      throw std::runtime_error("GUI element " + element.name + ": choices are needed for radio buttons and dropdown menus, and only allowed for them and sliders");
+    }
+    mConfigRTTI->guiElements.emplace_back(configRTTIInfo::guiElementCallbacks{element.rttiIndex, std::move(element.set), std::move(element.get)});
+  };
+  auto addArg = [&](auto& arg) {
+    if constexpr (std::is_same_v<std::remove_cvref_t<decltype(arg)>, guiElement>) {
+      addElement(arg);
+    } else if constexpr (std::is_same_v<std::remove_cvref_t<decltype(arg)>, bool>) {
+      frame.horizontal = arg;
+    } else {
+      frame.description = arg;
+    }
+  };
+  (addArg(args), ...);
+  mConfigRTTI->guiLayout.emplace_back(std::move(frame));
+}
+
+void GPUDisplayFrontend::setGUILayout(GPUDisplayGUIChannel& channel) const { channel.layout = mConfigRTTI->guiLayout; }
+
+std::vector<GPUDisplayGUIValue> GPUDisplayFrontend::getGUIValues()
+{
+  std::vector<GPUDisplayGUIValue> retVal;
+  retVal.reserve(mConfigRTTI->guiElements.size());
+  for (const auto& e : mConfigRTTI->guiElements) {
+    retVal.emplace_back(e.get());
+  }
+  return retVal;
+}
+
+void GPUDisplayFrontend::applyGUIValues(const std::vector<std::pair<uint32_t, GPUDisplayGUIValue>>& values)
+{
+  for (const auto& [id, value] : values) {
+    if (id >= mConfigRTTI->guiElements.size()) {
+      continue;
+    }
+    const auto& e = mConfigRTTI->guiElements[id];
+    try {
+      e.set(value);
+    } catch (const std::exception& ex) {
+      GPUError("Invalid value from the GUI for element %u: %s", id, ex.what());
+      continue;
+    }
+    if (mDisplay->mCfgC.mGuiPrintInfo && e.rttiIndex < mConfigRTTI->configInfos.size()) {
+      showConfigInfo(e.rttiIndex);
+    }
+  }
+}
+
 const std::vector<std::string>& GPUDisplayFrontend::getHelpText() const { return mConfigRTTI->helpText; }
 
 void GPUDisplayFrontend::listConfig()
@@ -256,8 +407,8 @@ void GPUDisplayFrontend::listConfig()
   std::sort(boundKeys.begin(), boundKeys.end(), [&](uint16_t a, uint16_t b) { return keyOrder(a) < keyOrder(b); });
   std::sort(availableKeys.begin(), availableKeys.end(), [&](uint16_t a, uint16_t b) { return keyOrder(a) < keyOrder(b); });
 
-  GPUInfo("Display config options with RTTI (struct, option, type, keys):");
-  uint32_t nOptionsWithKey = 0;
+  GPUInfo("Display config options with RTTI (struct, option, type, in Qt GUI, keys):");
+  uint32_t nOptionsWithKey = 0, nOptionsInGUI = 0;
   for (uint32_t i = 0; i < rtti.rttiEntries.size(); i++) {
     const auto& e = rtti.rttiEntries[i];
     std::string keys;
@@ -266,9 +417,12 @@ void GPUDisplayFrontend::listConfig()
         keys += (keys.empty() ? "[" : " [") + rtti.getKeyName(k) + "]";
       }
     }
+    const bool inGUI = std::any_of(rtti.guiElements.begin(), rtti.guiElements.end(), [i](const auto& g) { return g.rttiIndex == i; });
     nOptionsWithKey += !keys.empty();
-    GPUInfo("  %-28s %-32s %-12s %s", e.configStruct.c_str(), e.name.c_str(), e.type.c_str(), keys.c_str());
+    nOptionsInGUI += inGUI;
+    GPUInfo("  %-28s %-32s %-12s %-3s %s", e.configStruct.c_str(), e.name.c_str(), e.type.c_str(), inGUI ? "GUI" : "---", keys.c_str());
   }
+  GPUInfo("");
   GPUInfo("Bound keys (key, struct, option):");
   std::vector<std::string> mappedKeys(KEY_MAP_MAX);
   int32_t keyWidth = 0;
@@ -285,20 +439,28 @@ void GPUDisplayFrontend::listConfig()
       GPUInfo("  %-*s %-28s %s", keyWidth, ("[" + rtti.getKeyName(k) + "]").c_str(), hasRTTI ? rtti.rttiEntries[index].configStruct.c_str() : "(no config option)", hasRTTI ? rtti.rttiEntries[index].name.c_str() : "");
     }
   }
+  GPUInfo("");
   GPUInfo("Key down mappings (id, name, key):");
   for (uint32_t i = 0; i < KEY_MAP_MAX; i++) {
     GPUInfo("  %2u %-28s %s", i, rtti.keyMapNames[i].c_str(), mappedKeys[i].c_str());
   }
+  GPUInfo("");
   std::string available;
   for (uint16_t k : availableKeys) {
     available += (available.empty() ? "[" : " [") + rtti.getKeyName(k) + "]";
   }
   GPUInfo("Available keys: %s", available.c_str());
-  GPUInfo("%zu options with RTTI, %u of them with a key, %zu bound keys, %zu available keys", rtti.rttiEntries.size(), nOptionsWithKey, boundKeys.size(), availableKeys.size());
+  GPUInfo("Help text:");
+  for (const auto& line : rtti.helpText) {
+    GPUInfo("  %s", line.c_str());
+  }
+  GPUInfo("");
+  GPUInfo("%zu options with RTTI, %u of them with a key, %u in the Qt GUI, %zu bound keys, %zu available keys", rtti.rttiEntries.size(), nOptionsWithKey, nOptionsInGUI, boundKeys.size(), availableKeys.size());
 }
 
 #include "GPUDisplayFrontendConfigKeys.inc"
 #include "GPUDisplayFrontendConfigInfo.inc"
+#include "GPUDisplayFrontendConfigQtGUI.inc"
 
 void GPUDisplay::buildConfig()
 {
@@ -341,6 +503,7 @@ void GPUDisplay::buildConfig()
     };
   }
   buildConfigInfo();
+  buildConfigQtGUI();
   rtti->buildHelpText();
 }