decl_image_plane.hpp

#pragma once
 
#include <algorithm>
#include <memory>
#include <new>
#include <system_error>
#include <utility>
 
#include "../_cexports/c_img.h"
#include "../_cexports/c_utilities.h"
 
#include "../global.hpp"
#include "../point_2d.hpp"
 
#include "../data_type.hpp"
#include "../iarray.hpp"
#include "../image_plane_contiguous_iterator.hpp"
#include "../image_plane_linear_iterator.hpp"
#include "../image_plane_vpat_iterator.hpp"
 
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
 
 
 
class ImagePlane final
  : public IArray
{
  friend Image;
 
  public:
 
 
 
    ImagePlane(ImagePlane && other) noexcept = default;
 
 
 
    ImagePlane(const class Plane & plane);
 
 
 
    ~ImagePlane() = default;
 
    ImagePlane & operator=(ImagePlane && other) noexcept = default;
 
 
 
    void* Handle() const noexcept;
 
 
    bool TryContiguousAccess(std::uint8_t *&basePtr) const noexcept;
 
 
    std::uint8_t *ContiguousAccess() const;
 
 
    bool TryLinearAccess(LinearAccessData & linearAccessData) const noexcept;
 
 
    LinearAccessData LinearAccess() const;
 
 
 
    class DataType DataType() const noexcept override;
 
    int Rank() const noexcept
    {
      return 2;
    }
 
 
    const Image& Parent() const noexcept;
 
 
    class Vpat Vpat() const;
 
 
 
 
    std::unique_ptr<Image> Map() const;
 
 
 
 
    double GetPixel(Point2D<int> position) const;
 
 
    int Plane() const noexcept
    {
      return plane_;
    }
 
 
    template <class Type>
    ContiguousIterator<Type> BeginContiguous();
 
 
    template <class Type>
    ContiguousIterator<Type> EndContiguous();
 
 
    template <class Type>
    std::reverse_iterator<ContiguousIterator<Type>> RBeginContiguous();
 
 
    template <class Type>
    std::reverse_iterator<ContiguousIterator<Type>> REndContiguous();
 
 
    template <class Type>
    ContiguousConstIterator<Type> CBeginContiguous() const;
 
 
    template <class Type>
    ContiguousConstIterator<Type> BeginContiguous() const
    {
      return CBeginContiguous<Type>();
    }
 
 
    template <class Type>
    ContiguousConstIterator<Type> CEndContiguous() const;
 
 
    template <class Type>
    ContiguousConstIterator<Type> EndContiguous() const
    {
      return CEndContiguous<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<ContiguousConstIterator<Type>> CRBeginContiguous() const;
 
 
    template <class Type>
    std::reverse_iterator<ContiguousConstIterator<Type>> RBeginContiguous() const
    {
      return CRBeginContiguous<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<ContiguousConstIterator<Type>> CREndContiguous() const;
 
 
    template <class Type>
    std::reverse_iterator<ContiguousConstIterator<Type>> REndContiguous() const
    {
      return CEndContiguous<Type>();
    }
 
 
    template <class Type>
    LinearIterator<Type> BeginLinear();
 
 
    template <class Type>
    LinearIterator<Type> EndLinear();
 
 
    template <class Type>
    std::reverse_iterator<LinearIterator<Type>> RBeginLinear();
 
 
    template <class Type>
    std::reverse_iterator<LinearIterator<Type>> REndLinear();
 
 
    template <class Type>
    LinearConstIterator<Type> CBeginLinear() const;
 
 
    template <class Type>
    LinearConstIterator<Type> BeginLinear() const
    {
      return CBeginLinear<Type>();
    }
 
 
    template <class Type>
    LinearConstIterator<Type> CEndLinear() const;
 
 
    template <class Type>
    LinearConstIterator<Type> EndLinear() const
    {
      return CEndLinear<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<LinearConstIterator<Type>> CRBeginLinear() const;
 
 
    template <class Type>
    std::reverse_iterator<LinearConstIterator<Type>> RBeginLinear() const
    {
      return CRBeginLinear<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<LinearConstIterator<Type>> CREndLinear() const;
 
 
    template <class Type>
    std::reverse_iterator<LinearConstIterator<Type>> REndLinear() const
    {
      return CREndLinear<Type>();
    }
 
 
    template <class Type>
    VpatIterator<Type> BeginVpat();
 
 
    template <class Type>
    VpatIterator<Type> EndVpat();
 
 
    template <class Type>
    std::reverse_iterator <VpatIterator<Type>> RBeginVpat();
 
 
    template <class Type>
    std::reverse_iterator <VpatIterator<Type>> REndVpat();
 
 
    template <class Type>
    VpatConstIterator<Type> CBeginVpat() const;
 
 
    template <class Type>
    VpatConstIterator<Type> BeginVpat() const
    {
      return CBeginVpat<Type>();
    }
 
 
    template <class Type>
    VpatConstIterator<Type> CEndVpat() const;
 
 
    template <class Type>
    VpatConstIterator<Type> EndVpat() const
    {
      return CEndVpat<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<VpatConstIterator<Type>> CRBeginVpat() const;
 
 
    template <class Type>
    std::reverse_iterator<VpatConstIterator<Type>> RBeginVpat() const
    {
      return CRBeginVpat<Type>();
    }
 
 
    template <class Type>
    std::reverse_iterator<VpatConstIterator<Type>> CREndVpat() const;
 
 
    template <class Type>
    std::reverse_iterator<VpatConstIterator<Type>> REndVpat() const
    {
      return CREndVpat<Type>();
    }
 
  private:
 
 
 
    ImagePlane(int plane, const Image & image) noexcept
      : plane_(plane)
      , parentImage_(&image)
    {
    }
 
    int plane_;
 
    const Image * parentImage_ = nullptr;
 
    std::unique_ptr<WrappedImage> planeImage_;
};
 
template <>
struct PlaneTraits<ImagePlane>
{
  using PlaneT = ImagePlane;
  using TypeList = DispatchableTypeList<std::uint8_t, std::int8_t, std::uint16_t, std::int16_t, std::uint32_t,
                                        std::int32_t, std::uint64_t, std::int64_t, float, double>;
  
  static constexpr bool HasVpat = true;
 
  static int GetWidth(const ImagePlane &plane);
  static int GetHeight(const ImagePlane &plane);
 
  static Cvb::DataType GetDataType(const ImagePlane &plane)
  {
    return plane.DataType();
  }
 
  static constexpr int GetRank(const ImagePlane &)
  {
    return 2;
  }
 
  static Cvb::Vpat GetVpat(const ImagePlane &plane)
  {
    return plane.Vpat();
  }
};
 
CVB_END_INLINE_NS
 
}