lb_stream_header.h

#ifndef LB_STREAM_HEADER_H
#define LB_STREAM_HEADER_H
// Class that decodes the Ladybug stream header
#include<string>
#include<vector>

#pragma GCC visibility push(default)

// Define for MAC OS xcode build
//#define LB_MACOSX

namespace GRASP
{
  namespace Ladybug
  {
    enum LadybugStippledFormat
      {
        LADYBUG_BGGR,
        LADYBUG_GBRG,
        LADYBUG_GRBG,
        LADYBUG_RGGB    
      };
    
    void VerifySignature(const uint8_t *data);

    class StreamHeader
    {
    public:
      StreamHeader(const uint8_t *data);
      StreamHeader();
      virtual ~StreamHeader() {};

      void InitHeader(const uint8_t *data);
      
      void Print() const;
      uint32_t GetVersionNumber() const         { return version_number_; }
      uint32_t GetFrameRate() const             { return frame_rate_;}
      uint32_t GetBaseSerialNumber() const      { return base_serial_number_;}
      uint32_t GetHeadSerialNumber() const      { return head_serial_number_;}
      uint32_t GetPaddingBlockSize() const      { return padding_block_size_;}
      uint32_t GetDataFormat() const            { return data_format_;}
      uint32_t GetResolution() const            { return resolution_;}
      uint32_t GetStippledFormat() const        { return stippled_format_;}
      uint32_t GetConfigurationDataSize() const { return configuration_data_size_;}
      uint32_t GetNumberOfImages() const        { return number_of_images_;}
      uint32_t GetNumberOfIndexEntried() const  { return number_of_index_entries_;}
      uint32_t GetIncrement() const             { return increment_;}
      uint32_t GetStreamDataOffset() const      { return stream_data_offset_;}
      uint32_t GetGpsSummaryDataOffset() const  { return gps_summary_data_offset_;}
      uint32_t GetGpsSummaryDataSize() const    { return gps_summary_data_size_;}
    protected:
      uint32_t version_number_;
      uint32_t frame_rate_;
      uint32_t base_serial_number_;
      uint32_t head_serial_number_;
      uint32_t padding_block_size_;
      uint32_t data_format_;
      uint32_t resolution_;
      uint32_t stippled_format_;
      uint32_t configuration_data_size_;
      uint32_t number_of_images_;
      uint32_t number_of_index_entries_;
      uint32_t increment_;
      uint32_t stream_data_offset_;
      uint32_t gps_summary_data_offset_;
      uint32_t gps_summary_data_size_;
      std::vector<uint32_t> index_;
    };

    class ImageHeader
    {
    public: 
      ImageHeader();
      ImageHeader(const uint8_t *,fpos_t offset_in_file);
      ~ImageHeader() {};
      
      void Init(const uint8_t *,fpos_t offset_in_file);
      
      void Print() const;
      
      uint32_t GetDataSize()  const              { return data_size_; }
      uint32_t GetFingerprint() const            { return fingerprint_; }
      uint32_t GetVersionNumber() const          { return version_number_; }
      uint32_t GetTimeSeconds() const            { return time_s_; }
      uint32_t GetTimeMicroseconds() const       { return time_us_; }
      uint32_t GetSequenceId() const             { return sequence_id_; }
      uint32_t GetRefreshRate() const            { return refresh_rate_; }
      uint32_t GetGain(uint32_t camera) const    { if (camera<6) return gain_[camera];  else throw "Bad camera number"; }
      uint32_t GetWhiteBalance() const           { return white_balance_; }
      uint32_t GetBayerGain() const              { return bayer_gain_; }
      uint32_t GetBayerMap() const               { return bayer_map_; }
      uint32_t GetBrightness() const             { return brightness_; }
      uint32_t GetGamma() const                  { return gamma_; }
      uint32_t GetHeadSerialNumber() const       { return head_serial_number_; }
      uint32_t GetShutter(uint32_t camera) const { if (camera<6) return shutter_[camera]; else throw "Bad camera number"; }
      uint32_t GetJpegDataOffset(int plane) const{ return jpeg_data_offset[plane]; }
      uint32_t GetJpegDataSize(int plane) const  { return jpeg_data_size[plane]; }
      
      fpos_t GetImageOffset() const              { return offset_in_file_; }
    protected:
      uint32_t timestamp_;
      uint32_t data_size_;
      uint32_t fingerprint_;
      uint32_t version_number_;
      uint32_t time_s_;
      uint32_t time_us_;
      uint32_t sequence_id_;
      uint32_t refresh_rate_;
      uint32_t gain_[6];
      uint32_t white_balance_;
      uint32_t bayer_gain_;
      uint32_t bayer_map_;
      uint32_t brightness_;
      uint32_t gamma_;
      uint32_t head_serial_number_;
      uint32_t shutter_[6];
      uint32_t jpeg_data_offset[24];
      uint32_t jpeg_data_size[24];
      fpos_t offset_in_file_;
    };
    
    class GpsSummaryData
    {
    public:
      GpsSummaryData(uint32_t number_of_items);
      GpsSummaryData(const std::vector<uint8_t> &data);
      
      double GetLatitude(uint32_t image_number) const { return latitude_[image_number]; }

      double GetLongitude(uint32_t image_number) const { return longitude_[image_number]; }
      double GetAltitude(uint32_t image_number) const { return altitude_[image_number]; }

      uint32_t GetNumberOfItems() const { return number_of_items_; }
      uint32_t GetItemSize() const { return item_data_size_; }

      uint32_t GetSizeBytes() const { return data_.size(); }

      void SetGpsImage(uint32_t image_number, 
                      double lat, 
                      double lng, 
                      double alt);

      void SetLatitude(uint32_t image_number);
      void SetLongitude(uint32_t image_number);
      void SetAltitude(uint32_t image_number);

    protected:
      uint32_t number_of_items_;
      uint32_t item_data_size_;
      std::vector<double> latitude_;
      std::vector<double> longitude_;
      std::vector<double> altitude_;
      std::vector<uint8_t> data_;
    };

    class StreamFile : public StreamHeader
    {
    public:
      StreamFile(std::string &file_name, bool read_calibration=true);
      StreamFile();

      virtual ~StreamFile();

      void InitStream(std::string &file_name,bool read_calibration);

      std::string GetCalibrationData() const { return calibration_data_;}

      ImageHeader GetImagePlanesJpeg(uint32_t image_number,uint32_t camera_number,
                              std::vector<uint8_t> &C0,
                              std::vector<uint8_t> &C1,
                              std::vector<uint8_t> &C2,
                              std::vector<uint8_t> &C3) const;
      void GetCalibrationData(std::string &calib_str) const { calib_str=calibration_data_; }

      void CopyInsertGps(GpsSummaryData &gps, std::string &pgr_file_name) const;
    protected:
      void GetFrame(ImageHeader &image,uint32_t image_number) const;

      void GetBayerPlaneJpeg(const GRASP::Ladybug::ImageHeader &image,
                         uint32_t camera_number,uint32_t plane_number,
                         std::vector<uint8_t> &plane) const;

      std::string calibration_data_;
      FILE * stream_p_;
      uint8_t * header_p_;
      std::vector<uint8_t> image_header_;
      
      GpsSummaryData *gps_summary_data_;
    };
    
  }

}
#pragma GCC visibility pop
#endif

---