修改基础数据名称

src/common/meta.hpp

@@ -3,13 +3,44 @@
 
 #include "common/data.hpp"
 #include <opencv2/opencv.hpp>
+#include <vector>
 #include <string>
 
 namespace meta
 {
+// 数据类型
+enum class DataType {
+    FRAME = 0, // 帧数据
+    CONFIG = 2 // 配置数据
+};
+
+class BaseData
+{
+public:
+    BaseData() = delete;
+    explicit BaseData(DataType data_type) {
+        this->data_type = data_type;
+        create_time     = std::chrono::system_clock::now();
+    }
+
+public:
+    DataType                              data_type;    // 数据类型
+    std::chrono::system_clock::time_point create_time;  // 数据创建时间
+    std::string                           data_name;    // 数据名称/数据来源
 
-struct MetaData{
-    std::string from; // 图片来源
+};
+
+
+class FrameData : public BaseData
+{
+public:
+    explicit FrameData() : BaseData(DataType::FRAME) {
+        data_name = "FrameData";
+    }
+
+public:
+    std::string from; // 数据来源
+    int fps = 20;   // 帧率
     cv::Mat image; // 原始图片
     cv::Mat draw_image; // 画框图
     cv::Mat depth; // 深度图
@@ -18,6 +49,51 @@ struct MetaData{
     data::BoxArray result; // 分析结果
 };
 
+
+class AnalyzeConfigData : public BaseData
+{
+
+public:
+    explicit AnalyzeConfigData() : BaseData(DataType::CONFIG) {
+        data_name = "AnalyzeConfigData";
+    }
+
+public:
+    std::vector<std::string> algorithm_names; // 算法名称
+    std::unordered_map<std::string, std::vector<std::vector<cv::Point>>> algorithm_params_fence; // 算法电子围栏坐标点
+
+};
+
+
+class DrawConfigData : public BaseData
+{
+
+public:
+    explicit DrawConfigData() : BaseData(DataType::CONFIG) {
+        data_name = "DrawConfigData";
+    }
+
+public:
+    bool show_final_result = true; // 是否显示最终结果
+    bool show_original_result = true; // 是否显示原始结果
+};
+
+
+class SourceConfigData : public BaseData
+{
+public:
+    explicit SourceConfigData() : BaseData(DataType::CONFIG) {
+        data_name = "SourceConfigData";
+    }
+
+public:
+    int gpu_id = 0;
+    int skip_frame = 1; // 跳过的帧数
+
+
+}
+
+
 }
 
 

src/nodes/base/base.cpp

@@ -70,7 +70,7 @@ void BaseNode::work()
     }
 }
 
-void BaseNode::handle_data(std::shared_ptr<meta::MetaData>& data)
+void BaseNode::handle_data(std::shared_ptr<meta::BaseData>& data)
 {
     
 }

src/nodes/base/base.hpp

@@ -34,12 +34,12 @@ public:
     virtual ~BaseNode();
 
     virtual void work();
-    virtual void handle_data(std::shared_ptr<meta::MetaData>& data);
+    virtual void handle_data(std::shared_ptr<meta::BaseData>& data);
 
     void start();
     void stop();
 
-    inline void add_input_buffer(const std::string& name, std::shared_ptr<SharedQueue<std::shared_ptr<meta::MetaData>>> buffer)
+    inline void add_input_buffer(const std::string& name, std::shared_ptr<SharedQueue<std::shared_ptr<meta::BaseData>>> buffer)
     {
         std::unique_lock<std::mutex> lock(mutex_);
         std::weak_ptr<BaseNode> weak_self = shared_from_this();
@@ -53,7 +53,7 @@ public:
         input_buffers_[name] = buffer;
     }
 
-    inline void add_output_buffer(const std::string& name, std::shared_ptr<SharedQueue<std::shared_ptr<meta::MetaData>>> buffer)
+    inline void add_output_buffer(const std::string& name, std::shared_ptr<SharedQueue<std::shared_ptr<meta::BaseData>>> buffer)
     {
         std::unique_lock<std::mutex> lock(mutex_);
         output_buffers_[name] = buffer;
@@ -79,7 +79,8 @@ public:
         output_buffers_.erase(name);
     }
 
-    inline void send_output_data(const std::shared_ptr<meta::MetaData>& data) {
+    inline void send_output_data(const std::shared_ptr<meta::BaseData>& data) 
+    {
         if (!data) 
         {
             return;
@@ -108,15 +109,18 @@ protected:
     std::shared_ptr<std::condition_variable> cond_var_ =
         std::make_shared<std::condition_variable>();
     std::atomic<bool> running_{false};
-    std::unordered_map<std::string, std::shared_ptr<SharedQueue<std::shared_ptr<meta::MetaData>>>> input_buffers_;
-    std::unordered_map<std::string, std::shared_ptr<SharedQueue<std::shared_ptr<meta::MetaData>>>> output_buffers_;
+
+    std::shared_ptr<meta::BaseData> config_data_ = nullptr;
+
+    std::unordered_map<std::string, std::shared_ptr<SharedQueue<std::shared_ptr<meta::BaseData>>>> input_buffers_;
+    std::unordered_map<std::string, std::shared_ptr<SharedQueue<std::shared_ptr<meta::BaseData>>>> output_buffers_;
 };
 
 static inline void LinkNode(const std::shared_ptr<BaseNode> &front,
-    const std::shared_ptr<BaseNode> &back, int queue_size = 100, OverflowStrategy strategy = OverflowStrategy::Block) 
+    const std::shared_ptr<BaseNode> &back, int queue_size = 40, OverflowStrategy strategy = OverflowStrategy::DiscardOldest) 
 {
     PLOGI.printf("Link Node %s --> %s", front->get_name().c_str(), back->get_name().c_str());
-    auto queue = std::make_shared<SharedQueue<std::shared_ptr<meta::MetaData>>>(queue_size, strategy);
+    auto queue = std::make_shared<SharedQueue<std::shared_ptr<meta::BaseData>>>(queue_size, strategy);
     back->add_input_buffer(front->get_name(), queue);
     front->add_output_buffer(back->get_name(), queue);
 }

src/nodes/draw/drawNode.cpp

@@ -117,19 +117,20 @@ static float box_iou(const data::Box& box1, const data::Box& box2)
     return inter_area / (box1_area + box2_area - inter_area + 1e-6f); // Avoid division by zero
 }
 
-void DrawNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data) 
+void DrawNode::handle_data(std::shared_ptr<meta::BaseData>& meta_data) 
 {
+    auto frame_data = std::dynamic_pointer_cast<meta::FrameData>(meta_data);
     bool show_track = true;
-    cv::Mat image = meta_data->image.clone();
+    cv::Mat image = frame_data->image.clone();
     int image_width = image.cols;
     int image_height = image.rows;
     PositionManager<float> pm(getFontSize);
-    for (auto& box : meta_data->boxes)
+    for (auto& box : frame_data->boxes)
     {
         if (show_track)
         {
           float max_iou = 0.0f;
-          for (const auto& track_box : meta_data->track_boxes)
+          for (const auto& track_box : frame_data->track_boxes)
           {
             float iou = box_iou(box, track_box);
             if (iou > max_iou && iou > 0.7f)
@@ -184,7 +185,7 @@ void DrawNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
             }
         }
     }
-    meta_data->draw_image = image;
+    frame_data->draw_image = image;
 }
 
 }

src/nodes/draw/drawNode.hpp

@@ -17,7 +17,7 @@ public:
     DrawNode(const std::string& name) : BaseNode(name, NODE_TYPE::DES_NODE) {}
     virtual ~DrawNode() { stop(); };
 
-    void handle_data(std::shared_ptr<meta::MetaData>& meta_data) override;
+    void handle_data(std::shared_ptr<meta::BaseData>& meta_data) override;
 };
 
 } // namespace Node

src/nodes/infer/inferNode.cpp

@@ -23,10 +23,11 @@ void print_mat(const cv::Mat& mat, int max_rows = 10, int max_cols = 10)
 }
 
 
-void InferNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
+void InferNode::handle_data(std::shared_ptr<meta::BaseData>& meta_data)
 {
+    auto frame_data = std::dynamic_pointer_cast<meta::FrameData>(meta_data);
     checkRuntime(cudaSetDevice(device_id_));
-    cv::Mat image = meta_data->image;
+    cv::Mat image = frame_data->image;
     int width = image.cols;
     int height = image.rows;
 
@@ -37,14 +38,14 @@ void InferNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
         auto result = std::get<data::BoxArray>(det_result);
         for (auto& r : result)
         {
-            meta_data->boxes.push_back(r);
+            frame_data->boxes.push_back(r);
         }
     } 
     else if(std::holds_alternative<cv::Mat>(det_result))
     {
         auto depth_mat = std::get<cv::Mat>(det_result);
         // print_mat(depth_mat);
-        meta_data->depth = depth_mat;
+        frame_data->depth = depth_mat;
 
     }
     else

src/nodes/infer/inferNode.hpp

@@ -25,7 +25,7 @@ public:
         device_id_ = device_id;
     }
 
-    void handle_data(std::shared_ptr<meta::MetaData>& meta_data) override;
+    void handle_data(std::shared_ptr<meta::baseData>& meta_data) override;
 
 private:
     std::shared_ptr<Infer> model_ = nullptr;

src/nodes/record/recordNode.cpp

@@ -5,9 +5,14 @@
 namespace GNode
 {
 
-void RecordNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
+void RecordNode::handle_data(std::shared_ptr<meta::BaseData>& meta_data)
 {
-    cv::Mat image = meta_data->draw_image;
+    auto frame_data = std::dynamic_pointer_cast<meta::FrameData>(meta_data);
+    if (fps_ == 0)
+    {
+        fps_ = frame_data->fps;
+    }
+    cv::Mat image = frame_data->draw_image;
     int width = image.cols;
     int height = image.rows;
     if (!writer_.isOpened())

src/nodes/record/recordNode.hpp

@@ -31,9 +31,9 @@ public:
         }
     }
 
-    void handle_data(std::shared_ptr<meta::MetaData>& meta_data) override;
+    void handle_data(std::shared_ptr<meta::baseData>& meta_data) override;
 private:
-    int fps_ = 35;
+    int fps_ = 25;
     std::string gst_pipeline_;
     cv::VideoWriter writer_;
 };

src/nodes/stream/streamNode.cpp

@@ -30,7 +30,8 @@ bool StreamNode::open_stream() {
             status_ = StreamStatus::OPEN_FAILED;
             return false;
         }
-        PLOGI.printf("StreamNode [%s]: Stream fps %d", name_.c_str(), demuxer_->get_fps());
+        fps_ = demuxer_->get_fps();
+        PLOGI.printf("StreamNode [%s]: Stream fps %d", name_.c_str(), fps_);
 
         auto codec_id = demuxer_->get_video_codec();
 
@@ -189,10 +190,11 @@ void StreamNode::process_stream_folder()
             continue; // Skip frame
         }
 
-        auto metaData = std::make_shared<meta::MetaData>();
-        metaData->image = frame.clone();
-        metaData->from = name_;
-        send_output_data(metaData);
+        auto frame_data = std::make_shared<meta::FrameData>();
+        frame_data->image = frame.clone();
+        frame_data->from = name_;
+        frame_data->fps = fps_; // Set FPS for folder processing
+        send_output_data(frame_data);
     }
     status_ == StreamStatus::CLOSED;
     PLOGI.printf("StreamNode [%s]: Exiting FOLDER processing loop (Running: %s, Status: %d).",
@@ -233,10 +235,11 @@ void StreamNode::process_stream_cpu()
             continue; // Skip frame
         }
 
-        auto metaData = std::make_shared<meta::MetaData>();
-        metaData->image = frame.clone();
-        metaData->from = name_;
-        send_output_data(metaData);
+        auto frame_data = std::make_shared<meta::FrameData>();
+        frame_data->image = frame.clone();
+        frame_data->from = name_;
+        frame_data->fps = fps_; 
+        send_output_data(frame_data);
     }
     PLOGI.printf("StreamNode [%s]: Exiting CPU processing loop (Running: %s, Status: %d).",
             name_.c_str(), running_ ? "true" : "false", static_cast<int>(status_));
@@ -344,13 +347,14 @@ void StreamNode::process_stream_gpu()
                 continue; // Skip this decoded frame
             }
 
-            cv::Mat frame_gpu(decoder_->get_height(), decoder_->get_width(), CV_8UC3, frame_data);
+            cv::Mat frame(decoder_->get_height(), decoder_->get_width(), CV_8UC3, frame_data);
 
             // Create metadata and copy the frame data
-            auto metaData = std::make_shared<meta::MetaData>();
-            metaData->image = frame_gpu.clone(); // CLONE is crucial here!
-            metaData->from = name_;
-            send_output_data(metaData);
+            auto frame_data = std::make_shared<meta::FrameData>();
+            frame_data->image = frame.clone(); // CLONE is crucial here!
+            frame_data->from = name_;
+            frame_data->fps = fps_; // Use demuxer FPS for consistency
+            send_output_data(frame_data);
         }
         if (status_ == StreamStatus::ERROR) 
         {

src/nodes/stream/streamNode.hpp

@@ -93,6 +93,8 @@ private:
     int gpu_id_ = 0;
     int retry_delay_ms_; // Delay between reconnection attempts
 
+    int fps_ = 20;
+
     std::shared_ptr<cv::VideoCapture> cap_ = nullptr;
     std::shared_ptr<FFHDDemuxer::FFmpegDemuxer> demuxer_ = nullptr;
     std::shared_ptr<FFHDDecoder::CUVIDDecoder> decoder_ = nullptr;

src/nodes/track/trackNode.cpp

@@ -3,14 +3,15 @@
 namespace GNode
 {
 
-void TrackNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
+void TrackNode::handle_data(std::shared_ptr<meta::BaseData>& meta_data)
 {
-    if (!track_map_[meta_data->from] )
+    auto frame_data = std::dynamic_pointer_cast<meta::FrameData>(meta_data);
+    if (!track_map_[frame_data->from] )
     {
-        track_map_[meta_data->from] = std::make_shared<BYTETracker>(frame_rate_, track_buffer_);
+        track_map_[frame_data->from] = std::make_shared<BYTETracker>(frame_rate_, track_buffer_);
     }
     std::vector<Object> objects;
-    for (const auto& box : meta_data->boxes) 
+    for (const auto& box : frame_data->boxes) 
     {
         // 只处理需要的 label
         if (box.label == track_label_) { 
@@ -28,11 +29,11 @@ void TrackNode::handle_data(std::shared_ptr<meta::MetaData>& meta_data)
             }
         }
     }
-    std::vector<STrack> output_stracks = track_map_[meta_data->from] ->update(objects);
+    std::vector<STrack> output_stracks = track_map_[frame_data->from] ->update(objects);
 
     for (const auto& track : output_stracks) {
         const std::vector<float>& tlwh = track.tlwh;
-        meta_data->track_boxes.emplace_back(tlwh[0], tlwh[1], tlwh[0] + tlwh[2], tlwh[1] + tlwh[3], track.score, track.track_id, track_label_);
+        frame_data->track_boxes.emplace_back(tlwh[0], tlwh[1], tlwh[0] + tlwh[2], tlwh[1] + tlwh[3], track.score, track.track_id, track_label_);
     }
 
 };

src/nodes/track/trackNode.hpp

@@ -26,7 +26,7 @@ public:
         PLOGI.printf("TrackNode : [%s] Init. track label is %s, rate is %d, buffer is %d", name_.c_str(), track_label_.c_str(), frame_rate_, track_buffer_);
     }
     virtual ~TrackNode()  { stop(); };
-    void handle_data(std::shared_ptr<meta::MetaData>& meta_data) override;
+    void handle_data(std::shared_ptr<meta::BaseData>& meta_data) override;
 
 private:
     std::unordered_map<std::string, std::shared_ptr<BYTETracker>> track_map_;

src/graph/graph.cpp → src/pipeline/pipeline.cpp

@@ -1,8 +1,8 @@
-#include "graph/graph.hpp"
+#include "pipeline/pipeline.hpp"
 #include <fstream>
 
 
-namespace Graph
+namespace Pipe
 {
 
 using json = nlohmann::json;
@@ -27,7 +27,7 @@ static GNode::DecodeType string_to_decode_type(const std::string& type_str) {
 }
 
 
-void Graph::create_from_json(const std::string& json_path)
+void PipelineManager::create_from_json(const std::string& json_path)
 {
     std::ifstream json_file(json_path);
     if (!json_file.is_open()) 
@@ -44,10 +44,6 @@ void Graph::create_from_json(const std::string& json_path)
         throw std::runtime_error("Failed to parse JSON: " + std::string(e.what()));
     }
 
-    // shared_models_.clear();
-    // configured_pipelines_.clear();
-
-    // 2. Load Models
     if (config.contains("models")) 
     {
         for (auto& [model_id, model_config] : config["models"].items()) 

src/graph/graph.hpp → src/pipeline/pipeline.hpp

@@ -1,5 +1,5 @@
-#ifndef GRAPH_HPP__
-#define GRAPH_HPP__
+#ifndef PIPELINE_HPP__
+#define PIPELINE_HPP__
 
 #include <iostream>
 #include <vector>
@@ -18,7 +18,7 @@
 
 
 
-namespace Graph
+namespace Pipe
 {
 
 struct PipelineInstance {
@@ -27,12 +27,12 @@ struct PipelineInstance {
     std::vector<std::shared_ptr<GNode::BaseNode>> nodes; // 只包含此 pipeline 的节点，按顺序
 };
 
-class Graph
+class PipelineManager
 {
 
 public:
-    Graph() = default;
-    ~Graph() { }
+    PipelineManager() = default;
+    ~PipelineManager() { }
 
 
     // 获取配置好的 pipelines (只读)