LidarDataMessage.h

Go to the documentation of this file.

#ifndef LibMultiSense_LidarDataMessage
#define LibMultiSense_LidarDataMessage

#include <typeinfo>

#include "details/utility/Portability.hh"

namespace crl {
namespace multisense {
namespace details {
namespace wire {

class WIRE_HEADER_ATTRIBS_ LidarDataHeader {
public:

    static CRL_CONSTEXPR IdType      ID          = ID_DATA_LIDAR_SCAN;
    static CRL_CONSTEXPR VersionType VERSION     = 1;
    static CRL_CONSTEXPR uint32_t    SCAN_POINTS = 1081;

#ifdef SENSORPOD_FIRMWARE
    IdType      id;
    VersionType version;
#endif // SENSORDPOD_FIRMWARE

    uint32_t           scanCount;
    uint32_t           timeStartSeconds;
    uint32_t           timeStartMicroSeconds;
    uint32_t           timeEndSeconds;
    uint32_t           timeEndMicroSeconds;
    int32_t            angleStart; // microradians
    int32_t            angleEnd;
    uint32_t           points;
#ifdef SENSORPOD_FIRMWARE
    uint32_t           distanceP[SCAN_POINTS];   // millimeters
    uint32_t           intensityP[SCAN_POINTS];
#else
    uint32_t          *distanceP;
    uint32_t          *intensityP;
#endif // SENSORPOD_FIRMWARE

    LidarDataHeader()
        :
#ifdef SENSORPOD_FIRMWARE
        id(ID),
        version(VERSION),
#endif // SENSORPOD_FIRMWARE
        points(0) {};
};

#ifndef SENSORPOD_FIRMWARE

class LidarData : public LidarDataHeader {
public:

    //
    // Constructors

    LidarData(utility::BufferStreamReader&r, VersionType v) {serialize(r,v);};
    LidarData() {};

    //
    // Serialization routine

    template<class Archive>
        void serialize(Archive&          message,
                       const VersionType version)
    {
        message & scanCount;
        message & timeStartSeconds;
        message & timeStartMicroSeconds;
        message & timeEndSeconds;
        message & timeEndMicroSeconds;
        message & angleStart;
        message & angleEnd;
        message & points;

        const uint32_t rangeSize     = sizeof(uint32_t) * points;
        const uint32_t intensitySize = sizeof(uint32_t) * points;

        if (typeid(Archive) == typeid(utility::BufferStreamWriter)) {

            message.write(distanceP, rangeSize);
            message.write(intensityP, intensitySize);

        } else {

            distanceP = (uint32_t *) message.peek();
            message.seek(message.tell() + rangeSize);

            intensityP = (uint32_t *) message.peek();
            message.seek(message.tell() + intensitySize);
        }
    }
};

#endif // !SENSORPOD_FIRMWARE

}}}}; // namespaces

#endif