Network streaming

The dv-processing library an easy to integrate solution to stream data over network TCP connections with optional encryption for security or through local sockets. This achieved by using client-server paradigm implemented using two classes: dv::io::NetworkWriter and dv::io::NetworkReader. The dv::io::NetworkWriter acts as a server, supports multiple concurrent clients, and streams a single data type stream to the clients. The dv::io::NetworkReader connects to a server and is able to receive the streamed data.

This tutorial will introduce basic usage of these classes to stream event data using a network writer and receive the same data using network reader.

Network streaming server

The following sample implements a network streaming server using dv::io::NetworkWriter, that streams periodic event data, that is synthesized in software:

C++Python

#include <dv-processing/data/generate.hpp>
#include <dv-processing/io/network_writer.hpp>

int main() {
    using namespace std::chrono_literals;

    // Define image space resolution dimensions
    const cv::Size resolution(200, 200);

    // Define output event stream with valid resolution
    const dv::io::Stream stream = dv::io::Stream::EventStream(0, "events", "TEST_DATA", resolution);

    // Initiate the server, needs stream definition to initiate
    dv::io::NetworkWriter server("0.0.0.0", 10101, stream);

    // Print the ready state of the server
    std::cout << "Waiting for connections..." << std::endl;

    // Stream interval defines the packet frequency for this sample
    const dv::Duration streamInterval = 10ms;

    // Starting coordinates of the rectangle data that is going to be sent out in this sample
    cv::Point2i offset(0, 0);

    // Rectangle size in pixels
    const cv::Point2i rectSize(20, 20);

    // A boolean variable used to define movement direction of the rectangle
    bool direction = true;

    // Run indefinitely
    while (true) {
        // Do not produce output if there are no connected clients
        if (server.getClientCount() > 0) {
            // Generate the rectangle at given offset position
            const dv::EventStore events = dv::data::generate::eventRectangle(dv::now(), offset, offset + rectSize);

            // Increase or decrease the position coordinates depending on the "direction" boolean
            offset = direction ? offset + cv::Point2i(1, 1) : offset - cv::Point2i(1, 1);

            // Check if the rectangle coordinates reaches borders of the image
            if (offset.x == 0 || offset.y == 0 || offset.x + rectSize.x == resolution.width
                || offset.y + rectSize.y == resolution.height) {
                // Reverse the motion direction
                direction = !direction;
            }

            // Send it out to clients
            server.writeEvents(events);
        }

        // Sleep the application for the streaming interval duration
        std::this_thread::sleep_for(streamInterval);
    }

    return EXIT_SUCCESS;
}

Compiling and running the sample above will run an event streaming server, which is accessible on port 10101 on all available network devices. The instance will wait for a client to connect, next chapter will introduce a minimal client application to receive and visualize the streamed data.

Network streaming client

The following code sample provide a basic usage of dv::io::NetworkReader to receive network streamed data.

C++Python

#include <dv-processing/io/network_reader.hpp>
#include <dv-processing/visualization/event_visualizer.hpp>

#include <opencv2/highgui.hpp>

int main() {
    using namespace std::chrono_literals;

    // Initiate the client connection to the same port and localhost loopback address
    dv::io::NetworkReader client("127.0.0.1", 10101);

    // Validate that this client is connected to an event data stream
    if (!client.isEventStreamAvailable()) {
        throw dv::exceptions::RuntimeError("Server does not provide event data!");
    }

    // Initialize the event visualizer with server reported sensor resolution
    dv::visualization::EventVisualizer visualizer(client.getEventResolution().value());

    // Create a preview window to show the visualized events
    cv::namedWindow("Preview", cv::WINDOW_NORMAL);

    // Declare an event stream slicer to synchronized event data packets
    dv::EventStreamSlicer slicer;

    // Perform visualization every 10 milliseconds, which should match the server publishing frequency
    slicer.doEveryTimeInterval(10ms, [&visualizer](const dv::EventStore &events) {
        // Display preview image
        cv::imshow("Preview", visualizer.generateImage(events));

        // Short sleep, if user clicks escape key (code 27), exit the application
        if (cv::waitKey(2) == 27) {
            exit(0);
        }
    });

    // While client is connected
    while (client.isRunning()) {
        // Read the event data, validate, and feed into the slicer
        if (const auto events = client.getNextEventBatch(); events.has_value()) {
            slicer.accept(*events);
        }
    }

    return EXIT_SUCCESS;
}

This code sample connects to the port 10101 on local loopback network, receives event data stream and uses dv::visualization::EventVisualizer to generate a preview image of the event data.

Running the samples

We can now combine both samples to stream the synthetic events and visualize the output. First, run the server sample application, when it prints “Waiting for connections…”, launch the second client application, it should show the preview window with a small rectangle moving from corner to corner.

Preview of the rectangle that is received as event packets, the triangle is expected to move diagonally through the window pixel space.