Added a EMA convenience class & FPS counter to example1

Author: wjakob

include/nanogui/ema.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <nanogui/common.h>
+#include <cmath>
+
+NAMESPACE_BEGIN(nanogui)
+
+/// Exponentially weighted moving average accumulator with bias correction
+template <typename Value> class EMA {
+public:
+    /// Construct with given weight for old samples
+    /// The default weight (0.983) results in a ~1 second time constant at 60 FPS
+    EMA(Value weight = 0.983f)
+        : m_weights{weight, 1.f-weight}, m_value(0.f),
+          m_sample_count(0) {
+        if (weight < 0.f || weight >= 1.f)
+            throw std::invalid_argument("Weight must be in range [0, 1)");
+    }
+
+    /// Reset the accumulator to initial state
+    void reset() { m_value = 0.f; m_sample_count = 0; }
+
+    /// Add a new sample to the accumulator
+    void put(Value sample) {
+        m_value = std::fma(m_weights[0], m_value, sample * m_weights[1]);
+        m_sample_count++;
+    }
+
+    /// Get the bias-corrected accumulated value
+    Value value() const {
+        if (m_sample_count == 0)
+            return 0.f;
+        return m_value / (1.f - std::pow(m_weights[0], m_sample_count));
+    }
+
+    /// Get the current weight
+    Value weight() const { return m_weights[0]; }
+
+    /// Get the number of samples accumulated
+    size_t sample_count() const { return m_sample_count; }
+
+private:
+    Value m_weights[2];
+    Value m_value;
+    size_t m_sample_count;
+};
+
+NAMESPACE_END(nanogui)

include/nanogui/screen.h

@@ -17,6 +17,7 @@
 #include <nanogui/widget.h>
 #include <nanogui/texture.h>
 #include <nanogui/colorpass.h>
+#include <nanogui/ema.h>
 
 NAMESPACE_BEGIN(nanogui)
 
@@ -220,6 +221,12 @@ class NANOGUI_EXPORT Screen : public Widget {
     /// Does the framebuffer use a floating point representation
     bool has_float_buffer() const { return m_float_buffer; }
 
+    /// Get the index of the last (or current) frame being rendered
+    uint64_t frame_index() const { return m_frame_index; }
+
+    /// Get a smoothed estimate of the rendering time per frame (second-based)
+    double frame_time() const { return m_frame_timer.value(); }
+
     /// Does the screen apply color management as a post processing shader?
     bool applies_color_management() const {
 #if defined(NANOGUI_USE_METAL)
@@ -316,6 +323,7 @@ class NANOGUI_EXPORT Screen : public Widget {
     bool m_drag_active;
     Widget *m_drag_widget = nullptr;
     double m_last_interaction;
+    double m_last_draw;
     Color m_background;
     std::string m_caption;
     bool m_shutdown_glfw;
@@ -332,6 +340,8 @@ class NANOGUI_EXPORT Screen : public Widget {
     ref<Texture> m_depth_stencil_texture;
     ref<RestartableTimer> m_tooltip_timer;
     bool m_tooltip_force_visible = false;
+    EMA<double> m_frame_timer;
+    uint64_t m_frame_index;
 #if defined(NANOGUI_USE_METAL)
     void *m_metal_texture = nullptr;
     void *m_metal_drawable = nullptr;

src/example1.cpp

@@ -572,6 +572,12 @@ class ExampleApplication : public Screen {
         m_shader->end();
 
         m_render_pass->end();
+
+        if (m_frame_index % 60 == 59) {
+            char caption[128];
+            snprintf(caption, 128, "NanoGUI test (%.2f FPS)", 1.f / m_frame_timer.value());
+            set_caption(caption);
+        }
     }
 private:
     ProgressBar *m_progress;
@@ -591,7 +597,7 @@ int main(int /* argc */, char ** /* argv */) {
             ref<ExampleApplication> app = new ExampleApplication();
             app->dec_ref();
             app->set_visible(true);
-            nanogui::run(RunMode::Eager);
+            nanogui::run(RunMode::VSync);
         }
 
         nanogui::shutdown();

src/python/ema.cpp

@@ -0,0 +1,16 @@
+#ifdef NANOGUI_PYTHON
+
+#include "python.h"
+#include <nanogui/ema.h>
+
+void register_ema(nb::module_ &m) {
+    nb::class_<EMA>(m, "EMA", D(EMA))
+        .def(nb::init<float>(), "weight"_a = 0.983f, D(EMA, EMA))
+        .def("reset", &EMA::reset, D(EMA, reset))
+        .def("put", &EMA::put, "sample"_a, D(EMA, put))
+        .def("value", &EMA::value, D(EMA, value))
+        .def("weight", &EMA::weight, D(EMA, weight))
+        .def("sample_count", &EMA::sample_count, D(EMA, sample_count));
+}
+
+#endif

src/python/example1.py

@@ -12,7 +12,6 @@
 import nanogui as ng
 import math
 import time
-import gc
 import numpy as np
 
 from nanogui import glfw, icons
@@ -460,6 +459,9 @@ def draw_contents(self):
             with self.shader:
                 self.shader.draw_array(ng.Shader.PrimitiveType.Triangle, 0, 6, True)
 
+        if self.frame_index() % 60 == 59:
+            self.set_caption("NanoGUI test (%.2f FPS)" % (1 / self.frame_time()))
+
 
     def keyboard_event(self, key, scancode, action, modifiers):
         if super(TestApp, self).keyboard_event(key, scancode,
@@ -470,12 +472,12 @@ def keyboard_event(self, key, scancode, action, modifiers):
             return True
         return False
 
-if __name__ == "__main__":
+def main():
     ng.init()
     test = TestApp()
-    test.draw_all()
     test.set_visible(True)
     ng.run()
-    del test
-    gc.collect()
     ng.shutdown()
+
+if __name__ == "__main__":
+    main()

src/python/main.cpp

@@ -29,6 +29,7 @@ extern void register_nanovg(nb::module_ &m);
 extern void register_render(nb::module_ &m);
 extern void register_quad(nb::module_ &m);
 extern void register_chroma(nb::module_ &m);
+extern void register_ema(nb::module_ &m);
 
 #if defined(__APPLE__) || defined(__linux__)
 static void (*sigint_handler_prev)(int) = nullptr;

src/python/py_doc.h

@@ -864,6 +864,20 @@ static const char *__doc_nanogui_Cursor_IBeam = R"doc(< The I-beam cursor.)doc";
 
 static const char *__doc_nanogui_Cursor_VResize = R"doc(< The vertical resize cursor.)doc";
 
+static const char *__doc_nanogui_EMA = R"doc(Exponentially weighted moving average accumulator with bias correction)doc";
+
+static const char *__doc_nanogui_EMA_EMA = R"doc(Construct with given weight for old samples (default 0.983 = ~1 second at 60 FPS))doc";
+
+static const char *__doc_nanogui_EMA_put = R"doc(Add a new sample to the accumulator)doc";
+
+static const char *__doc_nanogui_EMA_reset = R"doc(Reset the accumulator to initial state)doc";
+
+static const char *__doc_nanogui_EMA_sample_count = R"doc(Get the number of samples accumulated)doc";
+
+static const char *__doc_nanogui_EMA_value = R"doc(Get the bias-corrected accumulated value)doc";
+
+static const char *__doc_nanogui_EMA_weight = R"doc(Get the current weight)doc";
+
 static const char *__doc_nanogui_FloatBox =
 R"doc(\class FloatBox textbox.h nanogui/textbox.h
 
@@ -1896,6 +1910,12 @@ finally draw_teardown().
 See also:
     redraw)doc";
 
+static const char *__doc_nanogui_Screen_frame_index =
+    "Get the index of the last (or current) frame being rendered";
+
+static const char *__doc_nanogui_Screen_frame_time =
+    "Get a smoothed estimate of the rendering time per frame (second-based)";
+
 static const char *__doc_nanogui_Screen_draw_contents =
 R"doc(Calls clear() and draws the window contents --- put your rendering
 code here.)doc";

src/python/widget.cpp

@@ -238,6 +238,8 @@ void register_widget(nb::module_ &m) {
         .def("nvg_flush", &Screen::nvg_flush, D(Screen, nvg_flush))
         .def("mouse_motion_event_f", &Screen::mouse_motion_event_f, "p"_a, "rel"_a,
              "button"_a, "modifiers"_a, D(Screen, mouse_motion_event_f))
+        .def("frame_time", &Screen::frame_time, D(Screen, frame_time))
+        .def("frame_index", &Screen::frame_index, D(Screen, frame_index))
 #if defined(NANOGUI_USE_METAL)
         .def("metal_layer", &Screen::metal_layer)
         .def("metal_texture", &Screen::metal_texture)

src/screen.cpp

@@ -510,7 +510,9 @@ void Screen::initialize(GLFWwindow *window, bool shutdown_glfw) {
     m_mouse_pos = Vector2i(0);
     m_mouse_state = m_modifiers = 0;
     m_drag_active = false;
-    m_last_interaction = glfwGetTime();
+    m_last_interaction = 0.0;
+    m_last_draw = 0.0;
+    m_frame_index = 0;
     m_redraw = true;
     __nanogui_screens.emplace_back(m_glfw_window, this);
 
@@ -761,6 +763,11 @@ void Screen::draw_all() {
 #if defined(NANOGUI_USE_METAL)
         void *pool = autorelease_init();
 #endif
+        float current_time = glfwGetTime();
+        if (m_last_draw != 0.0)
+            m_frame_timer.put(current_time - m_last_draw);
+        m_last_draw = current_time;
+        m_frame_index++;
 
         draw_setup();
         draw_contents();
@@ -801,7 +808,7 @@ void Screen::draw_tooltip() {
             return;
     } else {
         // Otherwise, decide based on timing information
-        double elapsed = glfwGetTime() - m_last_interaction;
+        double elapsed = m_last_draw - m_last_interaction;
         if (elapsed <= TOOLTIP_DELAY_SEC)
             return;
     }