crl::multisense::image::Header Class Reference

#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::mulisense::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 sucessfully 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(7200);

    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);
}

Definition at line 453 of file MultiSenseTypes.hh.

Constructor & Destructor Documentation

Header()

crl::multisense::image::Header::Header ( )

inline

Default Constructor

Definition at line 485 of file MultiSenseTypes.hh.

Member Function Documentation

inMask()

virtual bool crl::multisense::image::Header::inMask ( DataSource  mask )

inlinevirtual

Member function used to determine if the data contained in the header is contained in a specific image mask

Reimplemented from crl::multisense::HeaderBase.

Definition at line 492 of file MultiSenseTypes.hh.

Member Data Documentation

bitsPerPixel

uint32_t crl::multisense::image::Header::bitsPerPixel

Bits per pixel in the image

Definition at line 459 of file MultiSenseTypes.hh.

exposure

uint32_t crl::multisense::image::Header::exposure

The image exposure time in microseconds

Definition at line 472 of file MultiSenseTypes.hh.

frameId

int64_t crl::multisense::image::Header::frameId

Unique ID used to describe an image. FrameIds increase sequentally from the device

Definition at line 465 of file MultiSenseTypes.hh.

framesPerSecond

float crl::multisense::image::Header::framesPerSecond

The number of frames per second currently streaming from the device

Definition at line 476 of file MultiSenseTypes.hh.

gain

float crl::multisense::image::Header::gain

The imager gain the image was captured with

Definition at line 474 of file MultiSenseTypes.hh.

height

uint32_t crl::multisense::image::Header::height

Height of the image

Definition at line 463 of file MultiSenseTypes.hh.

imageDataP

const void* crl::multisense::image::Header::imageDataP

A pointer to the image data

Definition at line 480 of file MultiSenseTypes.hh.

imageLength

uint32_t crl::multisense::image::Header::imageLength

The length of the image data stored in imageDataP

Definition at line 478 of file MultiSenseTypes.hh.

source

DataSource crl::multisense::image::Header::source

DataSource corresponding to imageDataP

Definition at line 457 of file MultiSenseTypes.hh.

timeMicroSeconds

uint32_t crl::multisense::image::Header::timeMicroSeconds

The time microseconds value corresponding to when the image was captured

Definition at line 469 of file MultiSenseTypes.hh.

timeSeconds

uint32_t crl::multisense::image::Header::timeSeconds

The time seconds value corresponding to when the image was captured

Definition at line 467 of file MultiSenseTypes.hh.

width

uint32_t crl::multisense::image::Header::width

Width of the image

Definition at line 461 of file MultiSenseTypes.hh.

---

The documentation for this class was generated from the following file:

• MultiSenseTypes.hh