decl_array_access.hpp

#pragma once
 
#include <algorithm>
#include <array>
#include <cassert>
 
#include "../data_type.hpp"
#include "../size_2d.hpp"
#include "../rect.hpp"
 
#include "decl_access_base.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  class ImagePlane;
  class Vpat;
  class LinearAccessData;
 
  class ArrayAccess final : public ValueAccessBase<ArrayAccess>
  {
    /*
     * \brief Creates a new array access object.
     *
     * \pre
     * \a scan0 != \b nullptr, \a inc > 0 and \a width_ > 0
     *
     * \post
     * Valid() == \b true
     *
     * \param [in] scan0 Non-\b nullptr address of first pixel in plane.
     * \param [in] inc Increment to next pixel in bytes.
     * \param [in] width The pixel width of the buffer that is accessed.
     */
    explicit ArrayAccess(std::uint8_t *basePtr, std::intptr_t inc, int width) noexcept
        : basePtr_(basePtr)
        , inc_(inc)
        , width_(width)
    {
      assert(basePtr_ != nullptr && inc_ > 0 && width_ > 0); // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
    }
 
  public:
    ArrayAccess() noexcept;
 
 
    ArrayAccess(const ArrayAccess &other) noexcept = default;
    ArrayAccess &operator=(const ArrayAccess &other) noexcept = default;
    ArrayAccess(ArrayAccess&& other) noexcept = default;
    ArrayAccess& operator=(ArrayAccess && other) noexcept = default;
    ~ArrayAccess() = default;
 
    template <class PLANE_T>
    static ArrayAccess FromPlane(const PLANE_T &plane) noexcept;
 
    static ArrayAccess FromLinearAccess(const LinearAccessData &access, Size2D<int> size) noexcept;
 
    static ArrayAccess FromVpat(const Vpat &access, Size2D<int> size, DataType dataType) noexcept;
 
    LinearAccessData NewMoved(const Rect<int> newAoi) const noexcept;
 
    ArrayAccess NewMoved(int idx) const noexcept
    {
      return ArrayAccess{basePtr_ + idx * inc_, inc_, width_};
    }
 
    CVB_FORCE_INLINE std::uint8_t *BasePtr() const noexcept
    {
      return this->basePtr_;
    }
 
    CVB_FORCE_INLINE std::intptr_t XInc() const noexcept
    {
      return this->inc_;
    }
 
    CVB_FORCE_INLINE std::intptr_t YInc() const noexcept
    {
      return this->inc_ * this->width_;
    }
 
    CVB_FORCE_INLINE int Width() const noexcept
    {
      return this->width_;
    }
 
    bool Valid() const noexcept
    {
      return this->basePtr_ != 0 && this->inc_ > 0 && this->width_ > 0;
    }
 
    explicit operator bool() const noexcept
    {
      return this->Valid();
    }
 
    CVB_FORCE_INLINE const void *operator()(int x, int y) const noexcept
    {
      return reinterpret_cast<const void *>(this->basePtr_ + y * this->inc_ * this->width_ + x * this->inc_);
    }
 
    CVB_FORCE_INLINE void *operator()(int x, int y) noexcept
    {
      return reinterpret_cast<void *>(this->basePtr_ + y * this->inc_ * this->width_ + x * this->inc_);
    }
 
    CVB_FORCE_INLINE const void *operator[](int idx) const noexcept
    {
      return reinterpret_cast<const void *>(this->basePtr_ + idx * this->inc_);
    }
 
    CVB_FORCE_INLINE void *operator[](int idx) noexcept
    {
      return reinterpret_cast<void *>(this->basePtr_ + idx * this->inc_);
    }
 
    class Row
    {
      friend class ArrayAccess;
 
      std::uint8_t *line0_;  
      std::intptr_t xInc_;   
 
      /*
       * \brief Ctor.
       *
       * \param [in] line0 Address of the first pixel of the row.
       * \param [in] xInc Increment to next pixel in line.
       */
      Row(std::uint8_t *line0, std::intptr_t xInc) noexcept
          : line0_(line0)
          , xInc_(xInc)
      {
      }
 
    public:
      Row() noexcept
          : line0_(0)
          , xInc_(0)
      {
      }
 
 
      Row(const Row &other) noexcept = default;
      Row &operator=(const Row &other) noexcept = default;
      Row(Row&& other) noexcept = default;
      Row& operator=(Row&& other) noexcept = default;
      ~Row() = default;
 
      CVB_FORCE_INLINE void *operator[](int x) noexcept
      {
        return reinterpret_cast<void *>(line0_ + x * xInc_);
      }
 
      CVB_FORCE_INLINE const void *operator[](int x) const noexcept
      {
        return reinterpret_cast<const void *>(line0_ + x * xInc_);
      }
    };
 
    class Column
    {
      friend class ArrayAccess;
 
      std::uint8_t *column0_;  
      std::intptr_t yInc_;     
 
      /*
       * \brief Ctor.
       *
       * \param [in] column0 Address of the first pixel of the column.
       * \param [in] yInc Increment to next pixel in the column.
       */
      Column(std::uint8_t *column0, std::intptr_t yInc) noexcept
          : column0_(column0)
          , yInc_(yInc)
      {
      }
 
    public:
      Column() noexcept
          : column0_(0)
          , yInc_(0)
      {
      }
 
 
      Column(const Column& other) noexcept = default;
      Column& operator=(const Column& other) noexcept = default;
      Column(Column&& other) noexcept = default;
      Column& operator=(Column&& other) noexcept = default;
      ~Column() = default;
 
      CVB_FORCE_INLINE void *operator[](int y) noexcept
      {
        return reinterpret_cast<void *>(column0_ + y * yInc_);
      }
 
      CVB_FORCE_INLINE const void *operator[](int y) const noexcept
      {
        return reinterpret_cast<const void *>(column0_ + y * yInc_);
      }
    };
 
    Row RowAt(int y) const noexcept
    {
      return {basePtr_ + y * inc_ * width_, inc_};
    }
 
    Column ColumnAt(int x) const noexcept
    {
      return {basePtr_ + x * inc_, inc_ * width_};
    }
 
  private:
    std::uint8_t *basePtr_ = nullptr;  
    std::intptr_t inc_     = 0;        
    int width_             = 0;        
  };
 
  inline ArrayAccess::ArrayAccess() noexcept = default;
 
  inline bool operator!=(const ArrayAccess &lhs, const ArrayAccess &rhs) noexcept
  {
    return lhs.BasePtr() != rhs.BasePtr() || lhs.XInc() != rhs.XInc() || lhs.Width() != rhs.Width();
  }
 
  inline bool operator==(const ArrayAccess &lhs, const ArrayAccess &rhs) noexcept
  {
    return !(lhs != rhs);
  }
 
  inline bool IsInterleaved(size_t bytesPerPixel, const ArrayAccess &access0, const ArrayAccess &access1) noexcept
  {
    return access0.BasePtr() + bytesPerPixel == access1.BasePtr() && access0.XInc() == access1.XInc()
           && access0.YInc() == access1.YInc();
  }
 
  namespace // NOLINT(cert-dcl59-cpp)
  {
    inline bool IsInterleaved(size_t, const ArrayAccess &) noexcept
    {
      return true;
    }
 
    struct ArrayAccessFindNonInterleaved
    {
      size_t bytesPerPixel;
 
      inline bool operator()(const ArrayAccess *access0, const ArrayAccess *access1) const noexcept
      {
        return !IsInterleaved(bytesPerPixel, *access0, *access1);
      }
 
      inline bool operator()(const ArrayAccess &access0, const ArrayAccess &access1) const noexcept
      {
        return !IsInterleaved(bytesPerPixel, access0, access1);
      }
    };
 
  }  // namespace
 
  template <size_t I>
  bool IsInterleaved(std::size_t bytesPerPixel, const std::array<ArrayAccess, I> &accesses) noexcept
  {
    return std::adjacent_find(accesses.cbegin(), accesses.cend(), Cvb::ArrayAccessFindNonInterleaved{bytesPerPixel})
           == accesses.cend();
  }
 
  template <class... ACCESSES>
  bool IsInterleaved(size_t bytesPerPixel, const ArrayAccess &access0, const ArrayAccess &access1,
                     const ACCESSES &... accs) noexcept
  {
    const std::array<const ArrayAccess *, sizeof...(accs) + 2> arr{&access0, &access1, &accs...};
    return IsInterleaved(bytesPerPixel, arr);
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb