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() noexcept {…}


    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");
    }
    SensorSettings(double rangeScale, SensorPixelPosition pixelPosition, SensorPixelsMirrored pixelsMirrored, {…}


    double RangeScale() const noexcept
    {
      return rangeScale_;
    }
    double RangeScale() const noexcept {…}


    SensorPixelPosition PixelPosition() const noexcept
    {
      return pixelPosition_;
    }
    SensorPixelPosition PixelPosition() const noexcept {…}


    SensorPixelsMirrored PixelsMirrored() const noexcept
    {
      return pixelsMirrored_;
    }
    SensorPixelsMirrored PixelsMirrored() const noexcept {…}


    Rect<int> SensorRoi() const noexcept
    {
      return Rect<int>{Point2D<int>{offsetLeft_, offsetTop_}, Size2D<int>{width_, height_}};
    }
    Rect<int> SensorRoi() const noexcept {…}


    Point2D<double> ResolutionReduction() const noexcept
    {
      return {resolutionReductionX_, resolutionReductionY_};
    }
    Point2D<double> ResolutionReduction() const noexcept {…}


    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 {…}


    bool operator!=(const SensorSettings &other) const noexcept
    {
      return !(*this == other);
    }
    bool operator!=(const SensorSettings &other) const noexcept {…}
 
  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);
    }
  };
  class SensorSettings final {…};
#pragma pack(pop)
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb