#include <MultiSenseTypes.hh>

Inheritance diagram for crl::multisense::image::Header:

Public Member Functions
	Header ()

virtual bool	inMask (DataSource mask)

Public Member Functions inherited from crl::multisense::HeaderBase
virtual	~HeaderBase ()

Public Attributes
uint32_t	bitsPerPixel

uint32_t	exposure

int64_t	frameId

float	framesPerSecond

float	gain

uint32_t	height

const void *	imageDataP

uint32_t	imageLength

DataSource	source

uint32_t	timeMicroSeconds

uint32_t	timeSeconds

uint32_t	width

Detailed Description

Class containing image Header information common to all image types. This will be passed to any callback, of type image::Callback, that is subscribed to image data.

See crl::multisense::Channel::addIsolatedCallback for more details

Example code to extract 8 bit image data from a image header and display it using OpenCV (header.bitsPerPixel = 8)

#include <iostream>
#include <stdexcept>
#include <signal.h>
#include <unistd.h>
 
#include <MultiSenseTypes.hh>
#include <MultiSenseChannel.hh>
 
//
// Note this example has only been tested under Linux
#include <opencv2/opencv.hpp>
 
volatile bool doneG = false;
 
void signalHandler(int sig)
{
    std::cerr << "Shutting down on signal: " << strsignal(sig) << std::endl;
    doneG = true;
}
 
class Camera
{
    public:
        Camera(crl::multisense::Channel* channel);
        ~Camera();
        void imageCallback(const crl::multisense::image::Header& header);
 
    private:
        crl::multisense::Channel* m_channel;
};
 
namespace {
    //
    // Shim for the C-style callbacks accepted by
    // crl::multisense::Channel::addIsolatedCallback
    void monoCallback(const crl::multisense::image::Header& header, void* userDataP)
    { reinterpret_cast<Camera*>(userDataP)->imageCallback(header); }
};
 
 
Camera::Camera(crl::multisense::Channel* channel):
    m_channel(channel)
{
    crl::multisense::Status status;
 
    //
    // Attach our monoCallback to our Channel instance. It will get
    // called every time there is new Left Luma or Right luma image
    // data.
    status = m_channel->addIsolatedCallback(monoCallback,
                                           crl::multisense::Source_Luma_Left | crl::multisense::Source_Luma_Right,
                                           this);
 
    //
    // Check to see if the callback was successfully attached
    if(crl::multisense::Status_Ok != status) {
        throw std::runtime_error("Unable to attach isolated callback");
    }
 
    //
    // Start streaming luma images for the left and right cameras.
    m_channel->startStreams(crl::multisense::Source_Luma_Left | crl::multisense::Source_Luma_Right);
 
    //
    // Check to see if the streams were successfully started
    if(crl::multisense::Status_Ok != status) {
        throw std::runtime_error("Unable to start image streams");
    }
}
 
Camera::~Camera()
{
    crl::multisense::Status status;
 
    //
    // Remove our isolated callback.
    status = m_channel->removeIsolatedCallback(monoCallback);
 
    //
    // Check to see if the callback was successfully removed
    if(crl::multisense::Status_Ok != status) {
        throw std::runtime_error("Unable to remove isolated callback");
    }
 
    //
    // Stop streaming luma images for the left and right cameras
    m_channel->stopStreams(crl::multisense::Source_Luma_Left | crl::multisense::Source_Luma_Right);
 
    //
    // Check to see if the image streams were successfully stopped
    if(crl::multisense::Status_Ok != status) {
        throw std::runtime_error("Unable to stop streams");
    }
}
 
void Camera::imageCallback(const crl::multisense::image::Header& header)
{
    //
    // Create a container for the image data
    std::vector<uint8_t> imageData;
    imageData.resize(header.imageLength);
 
    //
    // Copy image data from the header's image data pointer to our
    // image container
    memcpy(&(imageData[0]), header.imageDataP, header.imageLength);
 
    //
    // Create a OpenCV matrix using our image container
    cv::Mat_<uint8_t> imageMat(header.height, header.width, &(imageData[0]));
 
    //
    // Display the image using OpenCV
    cv::namedWindow("Example");
    cv::imshow("Example", imageMat);
    cv::waitKey(1000./header.framesPerSecond);
}
 
 
int main()
{
    //
    // Setup a signal handler to kill the application
    signal(SIGINT, signalHandler);
 
    //
    // Instantiate a channel connecting to a sensor at the factory default
    // IP address
    crl::multisense::Channel* channel;
    channel = crl::multisense::Channel::Create("10.66.171.21");
 
    channel->setMtu(1500);
 
    try
    {
        Camera camera(channel);
        while(!doneG)
        {
            usleep(100000);
        }
    }
    catch(std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
 
    //
    // Destroy the channel instance
    crl::multisense::Channel::Destroy(channel);
}