LidarDataMessage.hh

Go to the documentation of this file.

 
#ifndef LibMultiSense_LidarDataMessage
#define LibMultiSense_LidarDataMessage
 
#include <typeinfo>
 
#include "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 // SENSORPOD_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)
    {
        (void) 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