Added Mask-RCNN based instance segmentation plugin with sample implementation.

#include "VP.h"
#include "../nodes/vp_file_src_node.h"
#include "../nodes/infers/vp_mask_rcnn_detector_node.h"
#include "../nodes/track/vp_sort_track_node.h"
#include "../nodes/osd/vp_osd_node_v3.h"
#include "../nodes/vp_screen_des_node.h"
#include "../utils/analysis_board/vp_analysis_board.h"

#if mask_rcnn_demo
int main() {
    VP_SET_LOG_LEVEL(vp_utils::vp_log_level::INFO);
    VP_LOGGER_INIT();

    auto video_input = std::make_shared<vp_nodes::vp_file_src_node>("video_input", 0, "./media/input.mp4", 0.6);
    auto segmentation_node = std::make_shared<vp_nodes::vp_mask_rcnn_detector_node>("seg_node", "./models/mask_rcnn/frozen_graph.pb", "./models/mask_rcnn/config.pbtxt", "./models/classes.txt");
    auto tracker = std::make_shared<vp_nodes::vp_sort_track_node>("tracker");
    auto overlay = std::make_shared<vp_nodes::vp_osd_node_v3>("overlay", "../assets/fonts/NotoSansCJKsc-Medium.otf");
    auto display = std::make_shared<vp_nodes::vp_screen_des_node>("display", 0);

    segmentation_node->attach_to({video_input});
    tracker->attach_to({segmentation_node});
    overlay->attach_to({tracker});
    display->attach_to({overlay});

    video_input->start();

    vp_utils::vp_analysis_board board({video_input});
    board.display();
}
#endif

Sementic Segmentation Integration

Introduced ENet-based semantic segmentation plugin with dual output capability.

#include "VP.h"
#include "../nodes/vp_file_src_node.h"
#include "../nodes/infers/vp_enet_seg_node.h"
#include "../nodes/osd/vp_seg_osd_node.h"
#include "../nodes/vp_screen_des_node.h"
#include "../utils/analysis_board/vp_analysis_board.h"

#if enet_segmentation_demo
int main() {
    VP_SET_LOG_LEVEL(vp_utils::vp_log_level::INFO);
    VP_LOGGER_INIT();

    auto source = std::make_shared<vp_nodes::vp_file_src_node>("source", 0, "./media/road_video.mp4");
    auto enet = std::make_shared<vp_nodes::vp_enet_seg_node>("enet_segmentor", "models/enet-cityscapes/enet-model.net");
    auto seg_overlay = std::make_shared<vp_nodes::vp_seg_osd_node>("seg_overlay", "models/enet-cityscapes/classes.txt", "models/enet-cityscapes/colors.txt");
    auto mask_display = std::make_shared<vp_nodes::vp_screen_des_node>("mask_display", 0, true, vp_objects::vp_size(400, 225));
    auto original_display = std::make_shared<vp_nodes::vp_screen_des_node>("original_display", 0, false, vp_objects::vp_size(400, 225));

    enet->attach_to({source});
    seg_overlay->attach_to({enet});
    mask_display->attach_to({seg_overlay});
    original_display->attach_to({seg_overlay});

    source->start();

    vp_utils::vp_analysis_board board({source});
    board.display();
}
#endif

Cascaded Multi-Inference Pipeline

Implemented multi-stage inference with chained detectors and classifires for hierarchical analysis.

#include "VP.h"
#include "../nodes/vp_file_src_node.h"
#include "../nodes/infers/vp_yolo_detector_node.h"
#include "../nodes/infers/vp_classifier_node.h"
#include "../nodes/osd/vp_osd_node.h"
#include "../nodes/vp_screen_des_node.h"
#include "../utils/analysis_board/vp_analysis_board.h"

#if cascaded_inference_demo
int main() {
    VP_SET_LOG_LEVEL(vp_utils::vp_log_level::INFO);
    VP_LOGGER_INIT();

    auto input_stream = std::make_shared<vp_nodes::vp_file_src_node>("input", 0, "media/traffic.mp4", 0.6);
    
    auto main_detector = std::make_shared<vp_nodes::vp_yolo_detector_node>("main_detector", 
        "models/vehicle/yolov3-tiny.weights", 
        "models/vehicle/yolov3-tiny.cfg", 
        "models/vehicle/classes.txt", 416, 416, 1);
    
    auto vehicle_type_classifier = std::make_shared<vp_nodes::vp_classifier_node>("type_classifier", 
        "models/vehicle/resnet18-type.onnx", "", 
        "models/vehicle/types.txt", 224, 224, 1, 
        std::vector<int>{1, 2, 3}, 10, false);
    
    auto color_classifier = std::make_shared<vp_nodes::vp_classifier_node>("color_classifier", 
        "models/vehicle/resnet18-color.onnx", "", 
        "models/vehicle/colors.txt", 224, 224, 1, 
        std::vector<int>{1, 2, 3}, 10, false);
    
    auto renderer = std::make_shared<vp_nodes::vp_osd_node>("renderer");
    auto output = std::make_shared<vp_nodes::vp_screen_des_node>("output", 0);

    main_detector->attach_to({input_stream});
    vehicle_type_classifier->attach_to({main_detector});
    color_classifier->attach_to({vehicle_type_classifier});
    renderer->attach_to({color_classifier});
    output->attach_to({renderer});

    input_stream->start();

    vp_utils::vp_analysis_board board({input_stream});
    board.display();
}
#endif

Image Source Input Plugin

Added configurable image input support from files or UDP streams with indeepndent channel control.

#include "VP.h"
#include "../nodes/vp_image_src_node.h"
#include "../nodes/infers/vp_yolo_detector_node.h"
#include "../nodes/osd/vp_osd_node.h"
#include "../nodes/vp_split_node.h"
#include "../nodes/vp_screen_des_node.h"
#include "../utils/analysis_board/vp_analysis_board.h"

#if image_input_demo
int main() {
    VP_SET_LOG_LEVEL(vp_utils::vp_log_level::INFO);
    VP_LOGGER_INIT();

    auto file_image_src = std::make_shared<vp_nodes::vp_image_src_node>("file_src", 0, "./assets/frames/frame_%d.jpg", 1, 0.4);
    auto udp_image_src = std::make_shared<vp_nodes::vp_image_src_node>("udp_src", 1, "6000", 3);
    
    auto detector = std::make_shared<vp_nodes::vp_yolo_detector_node>("detector", 
        "models/yolov3.weights", "models/yolov3.cfg", "models/classes.txt");
    auto overlay = std::make_shared<vp_nodes::vp_osd_node>("overlay");
    auto splitter = std::make_shared<vp_nodes::vp_split_node>("channel_splitter", true);
    auto display_0 = std::make_shared<vp_nodes::vp_screen_des_node>("display_0", 0);
    auto display_1 = std::make_shared<vp_nodes::vp_screen_des_node>("display_1", 1);
    
    detector->attach_to({file_image_src, udp_image_src});
    overlay->attach_to({detector});
    splitter->attach_to({overlay});
    display_0->attach_to({splitter});
    display_1->attach_to({splitter});

    file_image_src->start();
    udp_image_src->start();

    vp_utils::vp_analysis_board board({file_image_src, udp_image_src});
    board.display();
}
#endif

Image Output Destination Plugin

Implemented image output functionality for saving to files or transmitting via UDP with configurable intervals.

#include "VP.h"
#include "../nodes/vp_file_src_node.h"
#include "../nodes/infers/vp_yunet_face_detector_node.h"
#include "../nodes/infers/vp_sface_feature_encoder_node.h"
#include "../nodes/osd/vp_face_osd_node_v2.h"
#include "../nodes/vp_screen_des_node.h"
#include "../nodes/vp_image_des_node.h"
#include "../utils/analysis_board/vp_analysis_board.h"

#if image_output_demo
int main() {
    VP_SET_LOG_LEVEL(vp_utils::vp_log_level::INFO);
    VP_LOGGER_INIT();

    auto video_src = std::make_shared<vp_nodes::vp_file_src_node>("video_src", 0, "./media/faces.mp4", 0.6);
    auto face_detector = std::make_shared<vp_nodes::vp_yunet_face_detector_node>("face_detector", "./models/face/yunet.onnx");
    auto face_encoder = std::make_shared<vp_nodes::vp_sface_feature_encoder_node>("face_encoder", "./models/face/sface.onnx");
    auto face_overlay = std::make_shared<vp_nodes::vp_face_osd_node_v2>("face_overlay");
    auto screen_output = std::make_shared<vp_nodes::vp_screen_des_node>("screen", 0);
    
    auto image_output = std::make_shared<vp_nodes::vp_image_des_node>("image_out", 0, "192.168.1.100:6000", 3, vp_objects::vp_size(400, 200));

    face_detector->attach_to({video_src});
    face_encoder->attach_to({face_detector});
    face_overlay->attach_to({face_encoder});
    screen_output->attach_to({face_overlay});
    image_output->attach_to({face_overlay});

    video_src->start();

    vp_utils::vp_analysis_board board({video_src});
    board.display();
}
#endif