sensor_settings.hpp

#pragma once
 
#include <cvb/_cexports/c_img.h>
#include <cvb/core_3d.hpp>
#include <cvb/rect.hpp>
#include <cvb/point_2d.hpp>
 
namespace Cvb
{
CVB_BEGIN_INLINE_NS
 
 
#pragma pack(push, 4)
class SensorSettings final
{
public:
 
  SensorSettings() noexcept
    : size_(sizeof(CExports::CVC3DSensorSettings))
    , rangeScale_(1.0)
    , pixelPosition_(SensorPixelPosition::Absolute)
    , pixelsMirrored_(SensorPixelsMirrored::None)
    , offsetLeft_(0)
    , offsetTop_(0)
    , width_(0)
    , height_(0)
    , resolutionReductionX_(1.0)
    , resolutionReductionY_(1.0)
  {
  }
 
 
  SensorSettings(double rangeScale, SensorPixelPosition pixelPosition, SensorPixelsMirrored pixelsMirrored, Rect<int> sensorRoi, Point2D<double> resolutionReduction)
    : size_(sizeof(CExports::CVC3DSensorSettings))
    , rangeScale_(rangeScale)
    , pixelPosition_(pixelPosition)
    , pixelsMirrored_(pixelsMirrored)
    , offsetLeft_(sensorRoi.Left())
    , offsetTop_(sensorRoi.Top())
    , width_(sensorRoi.Width())
    , height_(sensorRoi.Height())
    , resolutionReductionX_(resolutionReduction.X())
    , resolutionReductionY_(resolutionReduction.Y())
{
    static_assert(sizeof(SensorSettings) == sizeof(CExports::CVC3DSensorSettings),
    "size of class SensorSettings and CExports::CVC3DSensorSettings must be equal");
 
    if (sensorRoi.Left() == 0 && sensorRoi.Top() == 0 && sensorRoi.Width() == 0 && sensorRoi.Height() == 0)
    {
      if (MirrorX() || MirrorY())
        throw std::invalid_argument("Sensor ROI is not valid");
    }
 
    if (!MirrorX() && sensorRoi.Width() < 0)
      throw std::invalid_argument("reverse_x = false and sensorRoi.Width < 0 are contradictory. Please set reverse_x to TRUE.");
 
    if (!MirrorY() && sensorRoi.Height() < 0)
      throw std::invalid_argument("reverse_y = false and sensorRoi.Height < 0 are contradictory. Please set reverse_y to TRUE.");
 
    if (sensorRoi.Left() < 0 || sensorRoi.Top() < 0)
      throw std::invalid_argument("Sensor ROI is not valid. Offset must be positive.");
 
    if (pixelPosition_ == SensorPixelPosition::Absolute && sensorRoi.Top() != 0)
      throw std::invalid_argument("Sensor ROI is not valid: sensorRoi.Top must be zero as absolutePosition = true");
  }
 
 
  double RangeScale() const noexcept { return rangeScale_; }
 
 
  SensorPixelPosition PixelPosition() const noexcept { return pixelPosition_; }
 
 
  SensorPixelsMirrored PixelsMirrored() const noexcept { return pixelsMirrored_; }
 
 
  Rect<int> SensorRoi() const noexcept 
  { 
    return Rect<int>{Point2D<int>{offsetLeft_, offsetTop_}, Size2D<int>{width_, height_}};
  }
 
 
  Point2D<double> ResolutionReduction() const noexcept { return { resolutionReductionX_, resolutionReductionY_ }; }
 
 
  bool operator==(const SensorSettings& other) const noexcept
  {
    return size_ == other.size_
      && rangeScale_ == other.rangeScale_
      && pixelPosition_ == other.pixelPosition_
      && pixelsMirrored_ == other.pixelsMirrored_
      && SensorRoi() == other.SensorRoi()
      && resolutionReductionX_ == other.resolutionReductionX_
      && resolutionReductionY_ == other.resolutionReductionY_;
  }
 
 
  bool operator!=(const SensorSettings& other) const noexcept
  {
    return !(*this == other);
  }
 
private:
  
  int size_;
  double rangeScale_;
  SensorPixelPosition pixelPosition_;
  SensorPixelsMirrored pixelsMirrored_;
 
  CExports::cvbdim_t offsetLeft_;
  CExports::cvbdim_t offsetTop_;
  CExports::cvbdim_t width_;
  CExports::cvbdim_t height_;
 
  // should be a Point2D as the packing shifts the start by 4 byte
  double resolutionReductionX_;
  double resolutionReductionY_;
 
  // Convenient functions
  bool MirrorX() const noexcept { return (pixelsMirrored_ == SensorPixelsMirrored::X || pixelsMirrored_ == SensorPixelsMirrored::XY); }
  bool MirrorY() const noexcept { return (pixelsMirrored_ == SensorPixelsMirrored::Y || pixelsMirrored_ == SensorPixelsMirrored::XY); }  
};
#pragma pack(pop)
 
CVB_END_INLINE_NS
 
}