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

}