map and chart widgets (#25)

README.md

@@ -3,27 +3,6 @@
 [![Build and Test](https://github.com/neri14/videographer/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/neri14/videographer/actions/workflows/build-and-test.yml)
 
 
-## ToDo
-- cleanup pipeline implementation after adding gpu
-- add -g --gpu flag to control if generation goes to cpu or gpu
-- add argument for controlling upscale (if then also control applied template)
-- implement overlay caching onto a single buffer of static texts and if overlay doesnt change between frames
-
-
-## Dependencies
-
-Packages required in system to build the application
-
-- CMake >= 3.23
-- Make / Ninja
-- GCC >= 14.x
-- googlemock
-- gstreamer >= 1.24
-- cairo
-- pango
-- pugixml
-
-
 ## Building and testing
 
 1. ```cmake -B build``` generate cmake files to build directory
@@ -36,12 +15,26 @@ Packages required in system to build the application
 
 1. Get video and telemetry
 1. Run concat tool to combine the clips
-1. Run trim tool to get final base video
+1. Run trim tool to create final raw video
 1. Run alignment tool and figure out offset
-1. Run generator app to generate base video (upscaled to 4K for YT)
+1. Run generator app to generate final video (for YT - set upscale to 4K (```-r 3840x2160```))
 1. Upload
 
 
+## Dependencies
+
+Packages required in system to build the application
+
+- CMake >= 3.23
+- Make / Ninja
+- GCC >= 14.x
+- googlemock
+- gstreamer >= 1.24
+- cairo
+- pango
+- pugixml
+
+
 ## Alignment Tool
 
 Python alignment tool is located in tools/alignment.

src/telemetry/telemetry.cpp

@@ -11,7 +11,8 @@ namespace helper {
     }
 }
 
-telemetry::telemetry(std::shared_ptr<datapoint_sequence> seq, long offset)
+telemetry::telemetry(std::shared_ptr<datapoint_sequence> seq, long offset) :
+    points(*seq)
 {
     if (!seq) {
         log.warning("No telemetry loaded");
@@ -26,7 +27,7 @@ telemetry::telemetry(std::shared_ptr<datapoint_sequence> seq, long offset)
     bool first = true;
     for (auto& data : *seq) {
         long us = std::chrono::duration_cast<std::chrono::microseconds>(data->timestamp - first_timestamp).count();
-        points[us+offset] = data;
+        time_points[us+offset] = data;
 
         if (!first) {
             sum += std::chrono::duration_cast<std::chrono::microseconds>(data->timestamp - prev_timestamp).count();
@@ -43,14 +44,19 @@ std::shared_ptr<datapoint> telemetry::get(double timestamp) const
 {
     long us = helper::in_microseconds(timestamp);
 
-    if (points.begin()->first > us) {
+    if (time_points.begin()->first > us) {
         return nullptr;
     }
-    if (points.rbegin()->first + avg_interval < us) {
+    if (time_points.rbegin()->first + avg_interval < us) {
         return nullptr;
     }
 
-    return (--points.lower_bound(us))->second;
+    return (--time_points.lower_bound(us))->second;
+}
+
+const std::vector<std::shared_ptr<datapoint>>& telemetry::get_all() const
+{
+    return points;
 }
 
 std::shared_ptr<telemetry> telemetry::load(const std::string& path, std::optional<double> offset)

src/telemetry/telemetry.h

@@ -15,14 +15,17 @@ class telemetry {
     ~telemetry() = default;
 
     std::shared_ptr<datapoint> get(double timestamp) const;
+    const std::vector<std::shared_ptr<datapoint>>& get_all() const;
 
     static std::shared_ptr<telemetry> load(const std::string& path, std::optional<double> offset); // optional offset in seconds
 
 private:
     utils::logging::logger log{"telemetry"};
 
     long avg_interval = 0;
-    std::map<long, std::shared_ptr<datapoint>> points;
+
+    std::vector<std::shared_ptr<datapoint>> points;
+    std::map<long, std::shared_ptr<datapoint>> time_points;
 };
 
 } // namespace telemetry

src/video/overlay/layout.cpp

@@ -2,6 +2,8 @@
 #include "widget/string_widget.h"
 #include "widget/value_widget.h"
 #include "widget/timestamp_widget.h"
+#include "widget/chart_widget.h"
+#include "widget/map_widget.h"
 #include "utils/logging/logger.h"
 
 #include <string>
@@ -94,6 +96,10 @@ bool layout_parser::create_widget(pugi::xml_node node, int x_offset, int y_offse
         return create_string_widget(node, x_offset, y_offset);
     } else if (type == "value") {
         return create_value_widget(node, x_offset, y_offset);
+    } else if (type == "chart") {
+        return create_chart_widget(node, x_offset, y_offset);
+    } else if (type == "map") {
+        return create_map_widget(node, x_offset, y_offset);
     }
 
     log.error("Unknown widget type \"{}\"", type);
@@ -113,41 +119,75 @@ layout_parser::common_text_params layout_parser::text_params(pugi::xml_node node
     };
 }
 
+layout_parser::common_chart_params layout_parser::chart_params(pugi::xml_node node, int x_offset, int y_offset, bool& out_status)
+{
+    return {
+        mandatory_attribute(node, "x", out_status).as_int() + x_offset,
+        mandatory_attribute(node, "y", out_status).as_int() + y_offset,
+        mandatory_attribute(node, "width", out_status).as_int(),
+        mandatory_attribute(node, "height", out_status).as_int(),
+        color_from_string(mandatory_attribute(node, "line-color", out_status).as_string()),
+        mandatory_attribute(node, "line-width", out_status).as_int(),
+        color_from_string(mandatory_attribute(node, "point-color", out_status).as_string()),
+        mandatory_attribute(node, "point-size", out_status).as_int()
+    };
+}
+
 bool layout_parser::create_timestamp_widget(pugi::xml_node node, int x_offset, int y_offset)
 {
     bool status = true;
 
-    common_text_params txt = text_params(node, x_offset, y_offset, status);
+    auto txt = text_params(node, x_offset, y_offset, status);
     std::string format = mandatory_attribute(node, "format", status).as_string();
     int utcoffset = mandatory_attribute(node, "utcoffset", status).as_int();
 
     widgets->push_back(std::make_shared<timestamp_widget>(txt.x, txt.y, txt.align, txt.font, txt.color, txt.border_color, txt.border_width, format, utcoffset));
-
     return status;
 }
 
 bool layout_parser::create_string_widget(pugi::xml_node node, int x_offset, int y_offset)
 {
     bool status = true;
 
-    common_text_params txt = text_params(node, x_offset, y_offset, status);
+    auto txt = text_params(node, x_offset, y_offset, status);
     std::string text = mandatory_attribute(node, "text", status).as_string();
 
     widgets->push_back(std::make_shared<string_widget>(txt.x, txt.y, txt.align, txt.font, txt.color, txt.border_color, txt.border_width, text));
-
     return status;
 }
 
 bool layout_parser::create_value_widget(pugi::xml_node node, int x_offset, int y_offset)
 {
     bool status = true;
-    common_text_params txt = text_params(node, x_offset, y_offset, status);
+
+    auto txt = text_params(node, x_offset, y_offset, status);
     std::string key = mandatory_attribute(node, "key", status).as_string();
     int precision = mandatory_attribute(node, "precision", status).as_int();
 
     widgets->push_back(std::make_shared<value_widget>(txt.x, txt.y, txt.align, txt.font, txt.color, txt.border_color, txt.border_width, key, precision));
-    log.warning("Not yet implemented: layout_parser::create_value_widget");
-    return true;
+    return status;
+}
+
+bool layout_parser::create_chart_widget(pugi::xml_node node, int x_offset, int y_offset)
+{
+    bool status = true;
+
+    auto chrt = chart_params(node, x_offset, y_offset, status);
+    std::string x_key = mandatory_attribute(node, "x-key", status).as_string();
+    std::string y_key = mandatory_attribute(node, "y-key", status).as_string();
+
+    widgets->push_back(std::make_shared<chart_widget>(chrt.x, chrt.y, chrt.width, chrt.height, chrt.line_color, chrt.line_width, chrt.point_color, chrt.point_size, x_key, y_key));
+    return status;
+}
+
+bool layout_parser::create_map_widget(pugi::xml_node node, int x_offset, int y_offset)
+{
+    bool status = true;
+
+    auto chrt = chart_params(node, x_offset, y_offset, status);
+
+    widgets->push_back(std::make_shared<map_widget>(chrt.x, chrt.y, chrt.width, chrt.height, chrt.line_color, chrt.line_width, chrt.point_color, chrt.point_size));
+    return status;
 }
 
 pugi::xml_attribute layout_parser::mandatory_attribute(pugi::xml_node node, const std::string& attr_name, bool& out_status)

src/video/overlay/layout.h

@@ -25,6 +25,7 @@ class layout_parser {
 
 private:
     struct common_text_params;
+    struct common_chart_params;
 
     utils::logging::logger log{"layout::load"};
 
@@ -34,8 +35,11 @@ class layout_parser {
     bool create_timestamp_widget(pugi::xml_node node, int x_offset, int y_offset);
     bool create_string_widget(pugi::xml_node node, int x_offset, int y_offset);
     bool create_value_widget(pugi::xml_node node, int x_offset, int y_offset);
+    bool create_chart_widget(pugi::xml_node node, int x_offset, int y_offset);
+    bool create_map_widget(pugi::xml_node node, int x_offset, int y_offset);
 
     common_text_params text_params(pugi::xml_node node, int x_offset, int y_offset, bool& out_status);
+    common_chart_params chart_params(pugi::xml_node node, int x_offset, int y_offset, bool& out_status);
     pugi::xml_attribute mandatory_attribute(pugi::xml_node node, const std::string& attr_name, bool& out_status);
 
     std::shared_ptr<layout> widgets;
@@ -52,6 +56,17 @@ struct layout_parser::common_text_params{
     int border_width;
 };
 
+struct layout_parser::common_chart_params{
+    int x;
+    int y;
+    int width;
+    int height;
+    rgba line_color;
+    int line_width;
+    rgba point_color;
+    int point_size;
+};
+
 } // namespace overlay
 } // namespace video
 } // namespace vgraph

src/video/overlay/overlay.cpp

@@ -11,6 +11,7 @@ namespace overlay {
 
 overlay::overlay(std::shared_ptr<layout> lay, std::shared_ptr<telemetry::telemetry> tele, std::pair<int, int> resolution, bool timecode):
     tele_(tele),
+    layout_(*lay),
     width(resolution.first),
     height(resolution.second)
 {
@@ -49,12 +50,14 @@ void overlay::precache()
 {
     auto t1 = std::chrono::high_resolution_clock::now();
 
-    cairo_t* cr = cairo_create(static_cache);
+    for (auto w : layout_) {
+        w->prepare(tele_->get_all());
+    }
 
+    cairo_t* cr = cairo_create(static_cache);
     for (auto w : static_widgets_) {
         w->draw_static(cr);
     }
-
     cairo_destroy(cr);
 
     auto t2 = std::chrono::high_resolution_clock::now();

src/video/overlay/overlay.h

@@ -41,6 +41,8 @@ class overlay {
     int cache_hit = 0;
     int cache_miss = 0;
 
+    std::vector<std::shared_ptr<widget>> layout_;
+
     std::vector<std::shared_ptr<widget>> static_widgets_;
     std::vector<std::shared_ptr<widget>> dynamic_widgets_;
     std::shared_ptr<timecode_widget> tc_widget_;

src/video/overlay/widget/CMakeLists.txt

@@ -7,6 +7,8 @@ target_sources(vgraph_lib
         string_widget.cpp
         value_widget.cpp
         timestamp_widget.cpp
+        chart_widget.cpp
+        map_widget.cpp
         timecode_widget.cpp
         text_align.cpp
         color.cpp
@@ -16,6 +18,8 @@ target_sources(vgraph_lib
         string_widget.h
         value_widget.h
         timestamp_widget.h
+        chart_widget.h
+        map_widget.h
         timecode_widget.h
         text_align.h
         color.h