C++ Example

This example demonstrates how to use the epc::TOFCam API to capture distance and amplitude frames from the EPC670 ToF camera module and display them in real time using OpenCV.

Prerequisites

• A connected EPC670 ToF camera module

• OpenCV 4.10 or later installed on the system (e.g. sudo apt install libopencv-dev)

• libepctofcam installed, see Installation for details.

Build

Compile and link the example code against the preinstalled libepctofcam library:

g++ cpp_example.cpp -o cpp_example \
    -std=c++17 \
    -lepctofcam \
    $(pkg-config --cflags --libs opencv4)

If pkg-config is not available for OpenCV, specify the flags manually:

g++ cpp_example.cpp -o cpp_example \
    -std=c++17 \
    -lepctofcam \
    -I/usr/include/opencv4 \
    -lopencv_core -lopencv_highgui -lopencv_imgproc

Run

./cpp_example

Press any key in the OpenCV window to stop the stream and exit.

Parameters

Parameter	Value	Description
ACQUISITION_MODE	DIST_AMP_HDR	Acquisition mode
HDR_INTEGRATION_TIME1_US	40 µs	HDR integration time (short)
HDR_INTEGRATION_TIME2_US	400 µs	HDR integration time (medium)
HDR_INTEGRATION_TIME3_US	4000 µs	HDR integration time (long)
MODULATION_FREQ_HZ	10 MHz	Modulation frequency

How It Works

1. Open the camera with cam.open().

2. Configure the acquisition mode, exposure time and modulation frequency via cam.setControl().

3. Start the stream with cam.startStream().

4. In a loop, capture frames with cam.captureFrame() and copy the distance and amplitude data into OpenCV matrices using std::memcpy.

5. The distance image is scaled to the unambiguity range of the sensor and colorized with the JET colormap. The amplitude image is colorized with the VIRIDIS colormap.

6. Both images are upscaled 2x using nearest-neighbor interpolation for better visibility on screen.

7. When a key is pressed, the stream is stopped with cam.stopStream() and the camera is closed with cam.close().

Full Source Code

#include <iostream>
#include <opencv2/opencv.hpp>

#include "epc/tofcam.hpp"

const int modulation_freq = 10e6; // 10 MHz
const int min_amplitude = 80;     // minimum amplitude threshold for valid distance measurements
const float max_distance = 2000.0f;
const int hdr_integration_times_us[3] = {40, 400, 4000}; // HDR integration times in microseconds

int main(int argc, char *argv[]) {

    epc::TOFCam cam;

    // connect to the TOFCam module
    int ret = cam.open();
    if (ret != 0) {
        std::cerr << "Failed to connect to camera module: " << strerror(-ret) << std::endl;
        return -1;
    }

    // set camera parameters
    cam.setControl(epc::ControlID::ACQUISITION_MODE, epc::AcquisitionMode::DIST_AMP_HDR);
    cam.setControl(epc::ControlID::HDR_INTEGRATION_TIME1_US, hdr_integration_times_us[0]);
    cam.setControl(epc::ControlID::HDR_INTEGRATION_TIME2_US, hdr_integration_times_us[1]);
    cam.setControl(epc::ControlID::HDR_INTEGRATION_TIME3_US, hdr_integration_times_us[2]);
    cam.setControl(epc::ControlID::MODULATION_FREQ_HZ, modulation_freq);
    cam.setControl(epc::ControlID::MIN_AMPLITUDE, min_amplitude);

    // start capturing frames
    ret = cam.startStream();
    if (ret != 0) {
        std::cerr << "Failed to start stream." << std::endl;
        return -1;
    }

    std::cout << "Camera is running. Press any key to quit..." << std::endl;

    // capture and display a frame every 10 ms if no key has been pressed
    while (cv::waitKey(10) < 0) {

        // get the latest frame
        std::unique_ptr<epc::TOFFrame> frame;
        ret = cam.captureFrame(frame);
        if (ret != 0) {
            std::cerr << "Failed to capture frame." << std::endl;
            return -1;
        }

        // create an OpenCV matrix from the image
        cv::Mat distance_raw(frame->getHeight(), frame->getWidth(), CV_16UC1);
        cv::Mat amplitude_raw(frame->getHeight(), frame->getWidth(), CV_16UC1);
        std::memcpy(distance_raw.data,
                    frame->get<epc::DistanceFrame>(0),
                    frame->getWidth() * frame->getHeight() * sizeof(uint16_t));
        std::memcpy(amplitude_raw.data,
                    frame->get<epc::AmplitudeFrame>(0),
                    frame->getWidth() * frame->getHeight() * sizeof(uint16_t));

        cv::Mat distance_scaled, amplitude_scaled;
        cv::convertScaleAbs(distance_raw, distance_scaled, 0xff / max_distance);
        cv::convertScaleAbs(amplitude_raw, amplitude_scaled, 0xff / 3000.0f);

        // apply colormap
        cv::Mat distance_colored, amplitude_colored;
        cv::applyColorMap(distance_scaled, distance_colored, cv::COLORMAP_JET);
        cv::applyColorMap(amplitude_scaled, amplitude_colored, cv::COLORMAP_VIRIDIS);

        // upscale images for larger display
        cv::Mat distance_upscaled, amplitude_upscaled;
        cv::resize(distance_colored,
                   distance_upscaled,
                   cv::Size(frame->getWidth() * 2, frame->getHeight() * 2),
                   0,
                   0,
                   cv::INTER_NEAREST);
        cv::resize(amplitude_colored,
                   amplitude_upscaled,
                   cv::Size(frame->getWidth() * 2, frame->getHeight() * 2),
                   0,
                   0,
                   cv::INTER_NEAREST);

        cv::imshow("TOFCam Distance", distance_upscaled);
        cv::imshow("TOFCam Amplitude", amplitude_upscaled);
    }

    cv::destroyAllWindows();

    // stop capturing frames
    ret = cam.stopStream();
    if (ret != 0) {
        std::cerr << "Failed to stop stream." << std::endl;
        return -1;
    }

    // close the connection to the camera module
    ret = cam.close();
    if (ret != 0) {
        std::cerr << "Failed to close the connection." << std::endl;
        return -1;
    }

    std::cout << "Done." << std::endl;
    return 0;
}