image_buffer_description.hpp

#pragma once
 
#include "../_cexports/c_gev_server.h"
#include "../global.hpp"
#include "../point_2d.hpp"
#include "../size_2d.hpp"
#include "../pfnc_format.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
  namespace GevServer
  {
    class ImageBufferDescription
    {
      friend class Stream;
      friend class ChunkImageBufferDescription;
 
    public:
      ImageBufferDescription(const ImageBufferDescription &other) noexcept            = default;
      ImageBufferDescription &operator=(const ImageBufferDescription &other) noexcept = default;
      ImageBufferDescription(ImageBufferDescription &&other) noexcept                 = default;
      ImageBufferDescription &operator=(ImageBufferDescription &&other) noexcept      = default;
      virtual ~ImageBufferDescription()                                               = default;

      ImageBufferDescription(Size2D<int> size, ColorModel colorModel, DataType dataType)
          : ImageBufferDescription(size, PfncFormatValue::From(colorModel, dataType))
      {
      }
      ImageBufferDescription(Size2D<int> size, ColorModel colorModel, DataType dataType) {…}

      ImageBufferDescription(Size2D<int> size, PfncFormat pixelFormat)
      {
        if (size.Width() < 1)
          throw std::runtime_error("Width must be larger or equal to 1");
        if (size.Height() < 1)
          throw std::runtime_error("Height must be larger or equal to 1");
        if (pixelFormat == PfncFormat::InvalidPixelFormat)
          throw std::runtime_error("Invalid pixel format");
 
        data_ = CExports::GSImageDataBlock{{CExports::TGSPayloadType::GSPT_Image},
                                           static_cast<CExports::cvbuint32_t>(pixelFormat),
                                           static_cast<CExports::cvbuint32_t>(size.Width()),
                                           static_cast<CExports::cvbuint32_t>(size.Height()),
                                           0,
                                           0,
                                           0,
                                           0,
                                           0};
      }
      ImageBufferDescription(Size2D<int> size, PfncFormat pixelFormat) {…}

      PfncFormat PixelFormat() const noexcept
      {
        return static_cast<PfncFormat>(data_.PixelFormat);
      }
      PfncFormat PixelFormat() const noexcept {…}

      void SetPixelFormat(const PfncFormat &pixelFormat)
      {
        if (pixelFormat == PfncFormat::InvalidPixelFormat)
          throw std::runtime_error("Invalid pixel format");
 
        data_.PixelFormat = static_cast<CExports::cvbuint32_t>(pixelFormat);
      }
      void SetPixelFormat(const PfncFormat &pixelFormat) {…}

      Size2D<int> Size() const noexcept
      {
        return Size2D<int>(static_cast<int>(data_.Width), static_cast<int>(data_.Height));
      }
      Size2D<int> Size() const noexcept {…}

      void SetSize(const Size2D<int> &size)
      {
        if (size.Width() < 1)
          throw std::runtime_error("Width must be larger or equal to 1");
        if (size.Height() < 1)
          throw std::runtime_error("Height must be larger or equal to 1");
 
        data_.Width  = static_cast<CExports::cvbuint32_t>(size.Width());
        data_.Height = static_cast<CExports::cvbuint32_t>(size.Height());
      }
      void SetSize(const Size2D<int> &size) {…}

      Point2D<int> Offset() const noexcept
      {
        return Point2D<int>(static_cast<int>(data_.XOffset), static_cast<int>(data_.YOffset));
      }
      Point2D<int> Offset() const noexcept {…}

      void SetOffset(Point2D<int> point)
      {
        if (point.X() < 0)
          throw std::runtime_error("X must be larger or equal to 0");
        if (point.Y() < 0)
          throw std::runtime_error("Y must be larger or equal to 0");
 
        data_.XOffset = static_cast<CExports::cvbuint32_t>(point.X());
        data_.YOffset = static_cast<CExports::cvbuint32_t>(point.Y());
      }
      void SetOffset(Point2D<int> point) {…}

      int LinePadding() const noexcept
      {
        return static_cast<int>(data_.XPadding);
      }
      int LinePadding() const noexcept {…}

      void SetLinePadding(int padding)
      {
        data_.XPadding = static_cast<CExports::cvbuint32_t>(padding);
      }
      void SetLinePadding(int padding) {…}
 
    private:
      CExports::GSImageDataBlock ImageDataBlock() const noexcept
      {
        return data_;
      }
 
      CExports::GSImageDataBlock data_ = {0};
    };
    class ImageBufferDescription {…};
  }  // namespace GevServer
  CVB_END_INLINE_NS
}  // namespace Cvb