frame.h

/*
 * Copyright 2022-present ifm electronic, gmbh
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef IFM3D_FG_FRAME_H
#define IFM3D_FG_FRAME_H
 
#include <chrono>
#include <cstdint>
#include <memory>
#include <type_traits>
#include <vector>
#include <ifm3d/device/device.h>
#include <ifm3d/fg/buffer.h>
#include <ifm3d/fg/module_frame_grabber.h>
 
namespace ifm3d
{
  enum class buffer_id : uint64_t
  {
    // clang-format off
    
    RADIAL_DISTANCE_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::RADIAL_DISTANCE_IMAGE), 
    
    NORM_AMPLITUDE_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::NORM_AMPLITUDE_IMAGE), 
    
    AMPLITUDE_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::AMPLITUDE_IMAGE), 
    
    GRAYSCALE_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::GRAYSCALE_IMAGE), 
    
    RADIAL_DISTANCE_NOISE = static_cast<uint64_t>(ifm3d::image_chunk::RADIAL_DISTANCE_NOISE), 
    
    REFLECTIVITY = static_cast<uint64_t>(ifm3d::image_chunk::REFLECTIVITY), 
    
    CARTESIAN_X_COMPONENT = static_cast<uint64_t>(ifm3d::image_chunk::CARTESIAN_X_COMPONENT), 
    
    CARTESIAN_Y_COMPONENT = static_cast<uint64_t>(ifm3d::image_chunk::CARTESIAN_Y_COMPONENT), 
    
    CARTESIAN_Z_COMPONENT = static_cast<uint64_t>(ifm3d::image_chunk::CARTESIAN_Z_COMPONENT), 
    
    CARTESIAN_ALL = static_cast<uint64_t>(ifm3d::image_chunk::CARTESIAN_ALL), 
    
    UNIT_VECTOR_ALL = static_cast<uint64_t>(ifm3d::image_chunk::UNIT_VECTOR_ALL), 
    
    MONOCHROM_2D_12BIT = static_cast<uint64_t>(ifm3d::image_chunk::MONOCHROM_2D_12BIT), 
    
    MONOCHROM_2D = static_cast<uint64_t>(ifm3d::image_chunk::MONOCHROM_2D), 
    
    JPEG_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::JPEG_IMAGE), 
    
    CONFIDENCE_IMAGE = static_cast<uint64_t>(ifm3d::image_chunk::CONFIDENCE_IMAGE), 
    
    DIAGNOSTIC = static_cast<uint64_t>(ifm3d::image_chunk::DIAGNOSTIC), 
    
    JSON_DIAGNOSTIC = static_cast<uint64_t>(ifm3d::image_chunk::JSON_DIAGNOSTIC), 
    
    EXTRINSIC_CALIB = static_cast<uint64_t>(ifm3d::image_chunk::EXTRINSIC_CALIB), 
    
    INTRINSIC_CALIB = static_cast<uint64_t>(ifm3d::image_chunk::INTRINSIC_CALIB), 
    
    INVERSE_INTRINSIC_CALIBRATION = static_cast<uint64_t>(ifm3d::image_chunk::INVERSE_INTRINSIC_CALIBRATION), 
    
 
    O3R_DISTANCE_IMAGE_INFO [[deprecated]] = static_cast<uint64_t>(ifm3d::image_chunk::TOF_INFO), 
    O3R_RGB_IMAGE_INFO [[deprecated]] = static_cast<uint64_t>(ifm3d::image_chunk::RGB_INFO), 
    
    TOF_INFO = static_cast<uint64_t>(ifm3d::image_chunk::TOF_INFO), 
    
    RGB_INFO = static_cast<uint64_t>(ifm3d::image_chunk::RGB_INFO), 
    
    JSON_MODEL = static_cast<uint64_t>(ifm3d::image_chunk::JSON_MODEL), 
    
    ALGO_DEBUG = static_cast<uint64_t>(ifm3d::image_chunk::ALGO_DEBUG), 
    
    O3R_ODS_OCCUPANCY_GRID = static_cast<uint64_t>(ifm3d::image_chunk::O3R_ODS_OCCUPANCY_GRID), 
    
    O3R_ODS_INFO = static_cast<uint64_t>(ifm3d::image_chunk::O3R_ODS_INFO), 
    
    O3R_RESULT_JSON = static_cast<uint64_t>(ifm3d::image_chunk::O3R_RESULT_JSON),
 
    O3R_RESULT_ARRAY2D = static_cast<uint64_t>(ifm3d::image_chunk::O3R_RESULT_ARRAY2D),
 
    O3R_RESULT_IMU = static_cast<uint64_t>(ifm3d::image_chunk::O3R_RESULT_IMU),
 
 
    XYZ = (std::numeric_limits<std::uint32_t>::max)(),
    
    EXPOSURE_TIME,
    
    ILLUMINATION_TEMP,
 
    O3R_ODS_FLAGS,
    O3R_MCC_LIVE_IMAGE,
    O3R_MCC_MOTION_IMAGE,
    O3R_MCC_STATIC_IMAGE,
    O3R_ODS_RENDERED_ZONES,
 
    // clang-format on
  };
  using TimePointT = std::chrono::time_point<std::chrono::system_clock,
                                             std::chrono::nanoseconds>;
 
  using BufferList = std::vector<Buffer>;
  using BufferDataListMap = std::map<ifm3d::buffer_id, BufferList>;
 
  class IFM3D_EXPORT Frame
  {
  public:
    using Ptr = std::shared_ptr<Frame>;
 
    Frame(const BufferDataListMap& images,
          const std::vector<TimePointT> timestamps,
          uint64_t frame_count);
    ~Frame();
 
    Frame(const Frame& t);
    Frame& operator=(const Frame& t);
 
    Frame(Frame&& t);
    Frame& operator=(Frame&& t);
 
    std::vector<TimePointT> TimeStamps();
 
    bool HasBuffer(buffer_id id);
 
    Buffer& GetBuffer(buffer_id id,
                      std::optional<size_t> index = std::nullopt);
 
    size_t GetBufferCount(buffer_id id);
 
    uint32_t FrameCount();
 
    std::vector<buffer_id> GetBuffers();
 
    decltype(std::declval<std::map<buffer_id, BufferList>>().begin())
    begin() noexcept;
    decltype(std::declval<const std::map<buffer_id, BufferList>>().begin())
    begin() const noexcept;
    decltype(std::declval<std::map<buffer_id, BufferList>>().end())
    end() noexcept;
    decltype(std::declval<const std::map<buffer_id, BufferList>>().end()) end()
      const noexcept;
 
  private:
    class Impl;
    std::unique_ptr<Impl> pImpl;
  }; // end: class Organizer
 
} // end: namespace ifm3d
 
#endif // IFM3D_FG_FRAME_H