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"
 
#include "decl_wrapped_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  class ImagePlane final : public IArray
  {
    friend Image;
 
  public:

    explicit ImagePlane(const class Plane &plane);
 
    ImagePlane(const ImagePlane &other)                = delete;
    ImagePlane &operator=(const ImagePlane &other)     = delete;
    ImagePlane(ImagePlane &&other) noexcept            = default;
    ImagePlane &operator=(ImagePlane &&other) noexcept = default;
    virtual ~ImagePlane()                              = default;


    void *Handle() const noexcept override;


    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 override
    {
      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
 
}  // namespace Cvb