Writing camera data

The dv-processing library provides a convenient way of recording camera data into AEDAT4 files. These files can record multiple data-types and can be read using existing tools in library. DV GUI software also provides ways to playback these recordings.

Writing a file

Files can be written using the dv::io::MonoCameraWriter class. Since the writer supports multiple data type configuration, it needs to know apriori what data streams are needed for writing. They are declared using a dv::io::MonoCameraWriter::Config structure and is passed to the constructor of the writer class to correctly initialise the required streams in the file header.

Defining output streams from an existing camera reader handle

As mentioned in the previous paragraph, number of output streams and their data-types needs to be known for the writer. Output streams definition can be generated by an input camera capture. In this case, the writer class will inspect what streams the capture can output and will create output streams for them. Following is an example on how to initialize a writer with a camera capture class:

C++Python

#include <dv-processing/io/camera_capture.hpp>
#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    // Open any camera
    dv::io::CameraCapture capture;

    // Create the writer instance, writer will inspect the capture capabilities and create output
    // streams for all available data streams from the capture instance.
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", capture);

    // Print which streams were configured
    std::cout << std::boolalpha;
    std::cout << "Is event stream available? " << writer.isEventStreamConfigured() << std::endl;
    std::cout << "Is frame stream available? " << writer.isFrameStreamConfigured() << std::endl;
    std::cout << "Is imu stream available? " << writer.isImuStreamConfigured() << std::endl;
    std::cout << "Is trigger stream available? " << writer.isTriggerStreamConfigured() << std::endl;

    return 0;
}

Defining output streams manually

Output streams definition can be manually defined in the config structure, following is a sample that manually defines event, frame, IMU, and trigger data-type streams and creates a writer instance:

C++Python

#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    dv::io::MonoCameraWriter::Config config("DVXplorer_sample");

    // Sample VGA resolution, same as the DVXplorer camera
    const cv::Size resolution(640, 480);

    // Add an event stream with a resolution
    config.addEventStream(resolution);

    // Add frame stream with a resolution
    config.addFrameStream(resolution);

    // Add IMU stream
    config.addImuStream();

    // Add trigger stream
    config.addTriggerStream();

    // Create the writer instance with the configuration structure
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Print which streams were configured
    std::cout << std::boolalpha;
    std::cout << "Is event stream available? " << writer.isEventStreamConfigured() << std::endl;
    std::cout << "Is frame stream available? " << writer.isFrameStreamConfigured() << std::endl;
    std::cout << "Is imu stream available? " << writer.isImuStreamConfigured() << std::endl;
    std::cout << "Is trigger stream available? " << writer.isTriggerStreamConfigured() << std::endl;

    return 0;
}

Defining output streams using predefined templates

The dv::io::MonoCameraWriter class provides some templates for configuration to reduce the code lines. Following is a sample how to use a named method that generates a config for writing data:

C++Python

#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    // Create a DVS config - events, imu, and triggers are going to be enabled
    const auto config = dv::io::MonoCameraWriter::DVSConfig("DVXplorer_sample", cv::Size(640, 480));

    // Create the writer instance with the configuration structure
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Print which streams were configured
    std::cout << std::boolalpha;
    std::cout << "Is event stream available? " << writer.isEventStreamConfigured() << std::endl;
    std::cout << "Is frame stream available? " << writer.isFrameStreamConfigured() << std::endl;
    std::cout << "Is imu stream available? " << writer.isImuStreamConfigured() << std::endl;
    std::cout << "Is trigger stream available? " << writer.isTriggerStreamConfigured() << std::endl;

    return 0;
}

A list of available output stream configurations available under the dv::io::MonoCameraWriter class:

• EventOnlyConfig - a single output stream “events”

• FrameOnlyConfig - a single output stream “frames”

• DVSConfig - three output streams: “events”, “imu”, and “trigger”

• DAVISConfig - four output streams: “events”, “frames”, “imu”, and “trigger”

Writing data to the file

The writer instance can be used to write data with the output streams configured. Following sections provide sample code on how to write individual data types using the writer class.

Writing events

The following sample shows an example on how to write event data using the dv::io::MonoCameraWriter class:

C++Python

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

int main() {
    // Sample VGA resolution, same as the DVXplorer camera
    const cv::Size resolution(640, 480);

    // Event only configuration
    const auto config = dv::io::MonoCameraWriter::EventOnlyConfig("DVXplorer_sample", resolution);

    // Create the writer instance, it will only have a single event output stream.
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Write 100 packet of event data
    for (int i = 0; i < 100; i++) {
        // EventStore requires strictly monotonically increasing data, generate
        // a timestamp from the iteration counter value
        const int64_t timestamp = i * 10000;

        // Generate sample event batch
        dv::EventStore events = dv::data::generate::dvLogoAsEvents(timestamp, resolution);

        // Write the packet using the writer, the data is not going be written at the exact
        // time of the call to this function, it is only guaranteed to be written after
        // the writer instance is destroyed (destructor has completed)
        writer.writeEvents(events);
    }

    return 0;
}

Writing frames

The following sample shows an example on how to write image frames using the dv::io::MonoCameraWriter class:

C++Python

#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    // Sample VGA resolution, same as the DVXplorer camera
    const cv::Size resolution(640, 480);

    // Frame only configuration
    const auto config = dv::io::MonoCameraWriter::FrameOnlyConfig("DVXplorer_sample", resolution);

    // Create the writer instance, it will only have a single frame output stream.
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Write 10 image frames
    for (int i = 0; i < 10; i++) {
        // Initialize a white image
        cv::Mat image(resolution, CV_8UC3, cv::Scalar(255, 255, 255));

        // Generate some monotonically increasing timestamp
        const int64_t timestamp = i * 1000;

        // Encapsulate the image in a frame that has a timestamp, this does not copy the pixel data
        dv::Frame frame(timestamp, image);

        // Write the frame
        writer.writeFrame(frame);
    }

    return 0;
}

Writing IMU data

The following sample shows an example on how to write IMU measurement data using the dv::io::MonoCameraWriter class:

C++Python

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

int main() {
    // IMU data only configuration
    auto config = dv::io::MonoCameraWriter::Config("DVXplorer_sample");
    config.addImuStream();

    // Create the writer instance, it will only have a single IMU data output stream
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Write 100 IMU measurements
    for (int i = 0; i < 100; i++) {
        // Generate some monotonically increasing timestamp
        const int64_t timestamp = i * 1000;

        // Some sample measurements - no rotation on gyro and a one-G gravity on Y axis of accelerometer
        const dv::IMU measurement = dv::data::generate::levelImuWithNoise(timestamp);

        // Write the measurement
        writer.writeImu(measurement);
    }

    return 0;
}

Writing trigger data

The following sample shows an example on how to write triggers using the dv::io::MonoCameraWriter class:

C++Python

#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    // Trigger data only configuration
    auto config = dv::io::MonoCameraWriter::Config("DVXplorer_sample");
    config.addTriggerStream();

    // Create the writer instance, it will only have a single trigger output stream
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Write 100 triggers
    for (int i = 0; i < 100; i++) {
        // Generate some monotonically increasing timestamp
        const int64_t timestamp = i * 1000;

        // Single trigger instance, let's say this is some signal from external source
        dv::Trigger trigger(timestamp, dv::TriggerType::EXTERNAL_GENERATOR_RISING_EDGE);

        // Write the trigger value
        writer.writeTrigger(trigger);
    }

    return 0;
}

[Advanced] Writing custom data types

The previous samples show how to use named functions for writing different data types into a file. C++ API provides templated methods to write any type of data. Below is sample that shows how to write data using the generic templated API:

Note

Since templated methods are only available in C++, the generic writing methods are only available in the C++ API.

#include <dv-processing/io/mono_camera_writer.hpp>

int main() {
    // Create a stream named "keypoints" for a data type of TimedKeyPoint packet
    auto config = dv::io::MonoCameraWriter::Config("DVXplorer_sample");

    // Define and contain a stream name in a variable
    const std::string streamName = "keypoints";

    // Add an output stream with a packet type and a defined stream name
    config.addStream<dv::TimedKeyPointPacket>(streamName);

    // Initialize the writer
    dv::io::MonoCameraWriter writer("mono_writer_sample.aedat4", config);

    // Let's create 10 packets of key-points
    for (int i = 0; i < 10; i++) {
        // Create a packet for writing
        dv::TimedKeyPointPacket packet;

        // Generate some monotonically increasing timestamp
        const int64_t timestamp = i * 1000;

        // 10 Let's generate 10 key-points for the packet
        for (int y = 0; y < 10; y++) {
            // Using emplace_back to directly allocate and insert the keypoint at the end of the vector
            packet.elements.emplace_back(dv::Point2f(5.f, 5.f), 10.f, 3.f, 1.f, 0, -1, timestamp);
        }

        // Write the packet using, requires a stream name that is the same with the
        writer.writePacket(packet, streamName);
    }

    return 0;
}

Sample application - recording data from live camera

An application writing multiple types of data from a live camera can be found among the code samples in the source code repository of the dv-processing library:

• Camera writer in C++

• Camera capture in Python