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
    : SensorSettings(1.0, SensorPixelPosition::Absolute, SensorPixelsMirrored::None, Rect<int>{Point2D<int>{0, 0}, Size2D<int> {0, 0}}, Point2D<double>{1.0, 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();
    resolutionReduction_ = resolutionReduction;
 
    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 resolutionReduction_; }
 
 
  bool operator==(const SensorSettings& other) const noexcept
  {
    if (size_ != other.size_)
      return false;
    else if (rangeScale_ != other.rangeScale_)
      return false;
    else if (pixelPosition_ != other.pixelPosition_)
      return false;
    else if (pixelsMirrored_ != other.pixelsMirrored_)
      return false;
    else if (SensorRoi()!= other.SensorRoi())
      return false;
    else if (resolutionReduction_ != other.resolutionReduction_)
      return false;
 
    return true;
  }
 
 
  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_;
 
  Point2D<double> resolutionReduction_;
 
  // 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
 
}