detail_image_plane.hpp

#pragma once
 
#include <algorithm>
#include <memory>
#include <new>
#include <system_error>
#include <utility>
 
#include "../_cexports/c_img.h"
 
#include "../global.hpp"
#include "../data_type.hpp"
 
#include "../_decl/decl_image_plane.hpp"
#include "../_decl/decl_vpat.hpp"
#include "../_decl/decl_linear_access.hpp"
#include "../_decl/decl_image.hpp"
#include "../plane.hpp"
#include "../_decl/decl_wrapped_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  inline ImagePlane::ImagePlane(const class Plane &plane)
      : plane_(0)
  {
    if (plane.Rank() != 2)
      throw std::runtime_error("only two dimensional planes can be converted to image planes");
 
    planeImage_ = WrappedImage::FromArray(plane);
  }
  inline ImagePlane::ImagePlane(const class Plane &plane) {…}
 
  inline void *ImagePlane::Handle() const noexcept
  {
    return Parent().Handle();
  }
  inline void *ImagePlane::Handle() const noexcept {…}
 
  inline bool ImagePlane::TryContiguousAccess(std::uint8_t *&basePtr) const noexcept
  {
    LinearAccessData linearAccess;
    if (!TryLinearAccess(linearAccess))
      return false;
    auto dataType = DataType();
    if (linearAccess.XInc() != dataType.BytesPerPixel())
      return false;
    auto size = Parent().Size();
    if (linearAccess.YInc()
        != static_cast<std::intptr_t>(size.Width()) * static_cast<std::intptr_t>(dataType.BytesPerPixel()))
      return false;
    basePtr = linearAccess.BasePtr();
    return true;
  }
  inline bool ImagePlane::TryContiguousAccess(std::uint8_t *&basePtr) const noexcept {…}
 
  inline std::uint8_t *ImagePlane::ContiguousAccess() const
  {
    std::uint8_t *basePtr = nullptr;
    if (!TryContiguousAccess(basePtr))
      throw std::runtime_error("failed to get contiguous access");
    return basePtr;
  }
  inline std::uint8_t *ImagePlane::ContiguousAccess() const {…}
 
  inline bool ImagePlane::TryLinearAccess(LinearAccessData &linearAccessData) const noexcept
  {
    void *basePtr      = nullptr;
    std::intptr_t xInc = 0;
    std::intptr_t yInc = 0;
    if (!CExports::GetLinearAccess(Handle(), static_cast<CExports::cvbdim_t>(plane_), &basePtr, &xInc, &yInc))
    {
      linearAccessData = LinearAccessData();
      return false;
    }
 
    linearAccessData = LinearAccessData(static_cast<std::uint8_t *>(basePtr), xInc, yInc, Parent().Width());
    return true;
  }
  inline bool ImagePlane::TryLinearAccess(LinearAccessData &linearAccessData) const noexcept {…}
 
  inline LinearAccessData ImagePlane::LinearAccess() const
  {
    LinearAccessData acc;
    if (!TryLinearAccess(acc))
      throw std::runtime_error("failed to get linear access");
    return acc;
  }
  inline LinearAccessData ImagePlane::LinearAccess() const {…}
 
  inline const Image &ImagePlane::Parent() const noexcept
  {
    if (planeImage_)
      return *planeImage_;
 
    return *parentImage_;
  }
  inline const Image &ImagePlane::Parent() const noexcept {…}
 
  inline class Vpat ImagePlane::Vpat() const
  {
    return Cvb::Vpat(Parent(), plane_);
  }
  inline class Vpat ImagePlane::Vpat() const {…}
 
  inline std::unique_ptr<Image> ImagePlane::Map() const
  {
    return Internal::DoBoolCallObjectOut<Image>([&](void *&img) {
      return CVB_CALL_CAPI(CreateImageSubList(Handle(), static_cast<CExports::cvbdim_t>(plane_), 1, true, img));
    });
  }
  inline std::unique_ptr<Image> ImagePlane::Map() const {…}
 
  inline double ImagePlane::GetPixel(Point2D<int> position) const
  {
    if (position.X() < 0 || position.Y() < 0 || position.X() >= Parent().Width() || position.Y() >= Parent().Height())
      throw std::invalid_argument("invalid image position");
 
    auto val = std::numeric_limits<double>::quiet_NaN();
 
    auto vpat     = Vpat();
    auto dataType = DataType();
 
    if (dataType.IsFloat())
    {
      switch (dataType.BytesPerPixel())
      {
        case sizeof(float):
          val = static_cast<double>(vpat.Value<float>(position));
          break;
 
        case sizeof(double):
          val = vpat.Value<double>(position);
          break;
 
        default:
          break;
      }
    }
    else if (dataType.IsSignedInteger())
    {
      switch (dataType.BytesPerPixel())
      {
        case sizeof(std::int8_t):
          val = static_cast<double>(vpat.Value<std::int8_t>(position));
          break;
 
        case sizeof(std::int16_t):
          val = static_cast<double>(vpat.Value<std::int16_t>(position));
          break;
 
        case sizeof(std::int32_t):
          val = static_cast<double>(vpat.Value<std::int32_t>(position));
          break;
 
        case sizeof(std::int64_t):
          val = static_cast<double>(vpat.Value<std::int64_t>(position));
          break;
 
        default:
          break;
      }
    }
    else
    {
      switch (dataType.BytesPerPixel())
      {
        case sizeof(std::uint8_t):
          val = static_cast<double>(vpat.Value<std::uint8_t>(position));
          break;
 
        case sizeof(std::uint16_t):
          val = static_cast<double>(vpat.Value<std::uint16_t>(position));
          break;
 
        case sizeof(std::uint32_t):
          val = static_cast<double>(vpat.Value<std::uint32_t>(position));
          break;
 
        case sizeof(std::uint64_t):
          val = static_cast<double>(vpat.Value<std::uint64_t>(position));
          break;
 
        default:
          break;
      }
    }
 
    return val;
  }
  inline double ImagePlane::GetPixel(Point2D<int> position) const {…}
 
  template <class Type>
  inline ContiguousIterator<Type> ImagePlane::BeginContiguous()
  {
    return ContiguousIterator<Type>(reinterpret_cast<Type *>(ContiguousAccess()), 0);
  }
  inline ContiguousIterator<Type> ImagePlane::BeginContiguous() {…}
 
  template <class Type>
  inline ContiguousIterator<Type> ImagePlane::EndContiguous()
  {
    auto size = Parent().Size();
    return ContiguousIterator<Type>(reinterpret_cast<Type *>(ContiguousAccess()), size.Width() * size.Height());
  }
  inline ContiguousIterator<Type> ImagePlane::EndContiguous() {…}
 
  template <class Type>
  inline std::reverse_iterator<ContiguousIterator<Type>> ImagePlane::RBeginContiguous()
  {
    return std::reverse_iterator<ContiguousIterator<Type>>(EndContiguous<Type>());
  }
  inline std::reverse_iterator<ContiguousIterator<Type>> ImagePlane::RBeginContiguous() {…}
 
  template <class Type>
  inline std::reverse_iterator<ContiguousIterator<Type>> ImagePlane::REndContiguous()
  {
    return std::reverse_iterator<ContiguousIterator<Type>>(BeginContiguous<Type>());
  }
  inline std::reverse_iterator<ContiguousIterator<Type>> ImagePlane::REndContiguous() {…}
 
  template <class Type>
  inline ContiguousConstIterator<Type> ImagePlane::CBeginContiguous() const
  {
    return ContiguousConstIterator<Type>(reinterpret_cast<Type *>(ContiguousAccess()), 0);
  }
  inline ContiguousConstIterator<Type> ImagePlane::CBeginContiguous() const {…}
 
  template <class Type>
  inline ContiguousConstIterator<Type> ImagePlane::CEndContiguous() const
  {
    auto size = Parent().Size();
    return ContiguousConstIterator<Type>(reinterpret_cast<Type *>(ContiguousAccess()), size.Width() * size.Height());
  }
  inline ContiguousConstIterator<Type> ImagePlane::CEndContiguous() const {…}
 
  template <class Type>
  inline std::reverse_iterator<ContiguousConstIterator<Type>> ImagePlane::CRBeginContiguous() const
  {
    return std::reverse_iterator<ContiguousConstIterator<Type>>(CEndContiguous<Type>());
  }
  inline std::reverse_iterator<ContiguousConstIterator<Type>> ImagePlane::CRBeginContiguous() const {…}
 
  template <class Type>
  inline std::reverse_iterator<ContiguousConstIterator<Type>> ImagePlane::CREndContiguous() const
  {
    return std::reverse_iterator<ContiguousConstIterator<Type>>(CBeginContiguous<Type>());
  }
  inline std::reverse_iterator<ContiguousConstIterator<Type>> ImagePlane::CREndContiguous() const {…}
 
  template <class Type>
  inline LinearIterator<Type> ImagePlane::BeginLinear()
  {
    return LinearIterator<Type>(LinearAccess(), Parent().Size());
  }
  inline LinearIterator<Type> ImagePlane::BeginLinear() {…}
 
  template <class Type>
  inline LinearIterator<Type> ImagePlane::EndLinear()
  {
    auto size = Parent().Size();
    return LinearIterator<Type>(LinearAccess(), Parent().Size(), Point2D<int>(0, size.Height()));
  }
  inline LinearIterator<Type> ImagePlane::EndLinear() {…}
 
  template <class Type>
  inline std::reverse_iterator<LinearIterator<Type>> ImagePlane::RBeginLinear()
  {
    return std::reverse_iterator<LinearIterator<Type>>(EndLinear<Type>());
  }
  inline std::reverse_iterator<LinearIterator<Type>> ImagePlane::RBeginLinear() {…}
 
  template <class Type>
  inline std::reverse_iterator<LinearIterator<Type>> ImagePlane::REndLinear()
  {
    return std::reverse_iterator<LinearIterator<Type>>(BeginLinear<Type>());
  }
  inline std::reverse_iterator<LinearIterator<Type>> ImagePlane::REndLinear() {…}
 
  template <class Type>
  inline LinearConstIterator<Type> ImagePlane::CBeginLinear() const
  {
    return LinearConstIterator<Type>(LinearAccess(), Parent().Size());
  }
  inline LinearConstIterator<Type> ImagePlane::CBeginLinear() const {…}
 
  template <class Type>
  inline LinearConstIterator<Type> ImagePlane::CEndLinear() const
  {
    auto size = Parent().Size();
    return LinearConstIterator<Type>(LinearAccess(), Parent().Size(), Point2D<int>(0, size.Height()));
  }
  inline LinearConstIterator<Type> ImagePlane::CEndLinear() const {…}
 
  template <class Type>
  inline std::reverse_iterator<LinearConstIterator<Type>> ImagePlane::CRBeginLinear() const
  {
    return std::reverse_iterator<LinearConstIterator<Type>>(CEndLinear<Type>());
  }
  inline std::reverse_iterator<LinearConstIterator<Type>> ImagePlane::CRBeginLinear() const {…}
 
  template <class Type>
  inline std::reverse_iterator<LinearConstIterator<Type>> ImagePlane::CREndLinear() const
  {
    return std::reverse_iterator<LinearConstIterator<Type>>(CBeginLinear<Type>());
  }
  inline std::reverse_iterator<LinearConstIterator<Type>> ImagePlane::CREndLinear() const {…}
 
  template <class Type>
  inline VpatIterator<Type> ImagePlane::BeginVpat()
  {
    return VpatIterator<Type>(Vpat(), Parent().Size());
  }
  inline VpatIterator<Type> ImagePlane::BeginVpat() {…}
 
  template <class Type>
  inline VpatIterator<Type> ImagePlane::EndVpat()
  {
    auto size = Parent().Size();
    return VpatIterator<Type>(Vpat(), Parent().Size(), Point2D<int>(0, size.Height()));
  }
  inline VpatIterator<Type> ImagePlane::EndVpat() {…}
 
  template <class Type>
  inline std::reverse_iterator<VpatIterator<Type>> ImagePlane::RBeginVpat()
  {
    return std::reverse_iterator<VpatIterator<Type>>(EndVpat<Type>());
  }
  inline std::reverse_iterator<VpatIterator<Type>> ImagePlane::RBeginVpat() {…}
 
  template <class Type>
  inline std::reverse_iterator<VpatIterator<Type>> ImagePlane::REndVpat()
  {
    auto size = Parent().Size();
    return std::reverse_iterator<VpatIterator<Type>>(BeginVpat<Type>());
  }
  inline std::reverse_iterator<VpatIterator<Type>> ImagePlane::REndVpat() {…}
 
  template <class Type>
  inline VpatConstIterator<Type> ImagePlane::CBeginVpat() const
  {
    return VpatConstIterator<Type>(Vpat(), Parent().Size());
  }
  inline VpatConstIterator<Type> ImagePlane::CBeginVpat() const {…}
 
  template <class Type>
  inline VpatConstIterator<Type> ImagePlane::CEndVpat() const
  {
    auto size = Parent().Size();
    return VpatConstIterator<Type>(Vpat(), Parent().Size(), Point2D<int>(0, size.Height()));
  }
  inline VpatConstIterator<Type> ImagePlane::CEndVpat() const {…}
 
  template <class Type>
  inline std::reverse_iterator<VpatConstIterator<Type>> ImagePlane::CRBeginVpat() const
  {
    return std::reverse_iterator<VpatConstIterator<Type>>(CEndVpat<Type>());
  }
  inline std::reverse_iterator<VpatConstIterator<Type>> ImagePlane::CRBeginVpat() const {…}
 
  template <class Type>
  inline std::reverse_iterator<VpatConstIterator<Type>> ImagePlane::CREndVpat() const
  {
    auto size = Parent().Size();
    return std::reverse_iterator<VpatConstIterator<Type>>(CBeginVpat<Type>());
  }
  inline std::reverse_iterator<VpatConstIterator<Type>> ImagePlane::CREndVpat() const {…}
 
  inline DataType ImagePlane::DataType() const noexcept
  {
    return DataType::FromNativeDescriptor(
        static_cast<int>(CExports::ImageDatatype(Handle(), static_cast<CExports::cvbdim_t>(plane_))));
  }
  inline DataType ImagePlane::DataType() const noexcept {…}
 
  inline int PlaneTraits<ImagePlane>::GetWidth(const ImagePlane &plane)
  {
    return plane.Parent().Width();
  }
 
  inline int PlaneTraits<ImagePlane>::GetHeight(const ImagePlane &plane)
  {
    return plane.Parent().Height();
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb