decl_linear_access.hpp

#pragma once
 
#include <algorithm>
#include <array>
#include <cassert>
 
#include "../data_type.hpp"
#include "../rect.hpp"
#include "../size_2d.hpp"
 
#include "decl_access_base.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  class ImagePlane;
  class ArrayAccess;
  class Vpat;
 
 
  class LinearAccessData final : public ValueAccessBase<LinearAccessData>
  {
    friend ImagePlane;
    friend ArrayAccess;
 
  public:
 
    LinearAccessData() noexcept;
 
    LinearAccessData(const LinearAccessData & other) noexcept = default;
    LinearAccessData &operator=(const LinearAccessData &other) noexcept = default;
    LinearAccessData(LinearAccessData&& other) noexcept = default;
    LinearAccessData& operator=(LinearAccessData&& other) noexcept = default;
    ~LinearAccessData() = default;
 
    template <class PLANE_T>
    static LinearAccessData FromPlane(const PLANE_T &plane) noexcept;
 
    static LinearAccessData FromVpat(const Vpat &access, Cvb::Size2D<int> size, Cvb::DataType dataType) noexcept;
 
    static LinearAccessData FromPtr(std::uint8_t *basePtr, std::intptr_t xInc, std::intptr_t yInc, int width) noexcept
    {
      return LinearAccessData{basePtr, xInc, yInc, width};
    }
 
    LinearAccessData NewMoved(const Cvb::Rect<int> newAoi) const noexcept
    {
      return LinearAccessData{basePtr_ + newAoi.Top() * yInc_ + newAoi.Left() * xInc_, xInc_, yInc_, newAoi.Width()};
    }
 
 
    std::uint8_t *BasePtr() const noexcept
    {
      return basePtr_;
    }
 
 
    std::intptr_t XInc() const noexcept
    {
      return xInc_;
    }
 
 
    std::intptr_t YInc() const noexcept
    {
      return yInc_;
    }
 
    CVB_FORCE_INLINE int Width() const noexcept
    {
      return this->width_;
    }
 
    bool Valid() const noexcept
    {
      return this->basePtr_ != nullptr && this->xInc_ != 0 && this->yInc_ != 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->yInc_ + x * this->xInc_);
    }
 
    CVB_FORCE_INLINE void *operator()(int x, int y) noexcept
    {
      return reinterpret_cast<void *>(this->basePtr_ + y * this->yInc_ + x * this->xInc_);
    }
 
    CVB_FORCE_INLINE const void *operator[](int idx) const noexcept
    {
      const int y = idx / this->width_;
      const int x = idx % this->width_;  // calculating / and % is faster than idx - width_ * y as the compiler generate
                                         // only a single idiv (or sdiv) for both lines
      return reinterpret_cast<const void *>(this->basePtr_ + y * this->yInc_ + x * this->xInc_);
    }
 
    CVB_FORCE_INLINE void *operator[](int idx) noexcept
    {
      const int y = idx / this->width_;
      const int x = idx % this->width_;  // calculating / and % is faster than idx - width_ * y as the compiler generate
                                         // only a single idiv (or sdiv) for both lines
      return reinterpret_cast<void *>(this->basePtr_ + y * this->yInc_ + x * this->xInc_);
    }
 
    class Row
    {
      friend class LinearAccessData;
 
      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_(nullptr)
          , 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 LinearAccessData;
 
      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_(nullptr)
          , 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 * yInc_, xInc_};
    }
 
    Column ColumnAt(int x) const noexcept
    {
      return {basePtr_ + x * xInc_, yInc_};
    }
 
  private:
    LinearAccessData(std::uint8_t *basePtr, std::intptr_t xInc, std::intptr_t yInc, int width) noexcept
        : basePtr_(basePtr)
        , xInc_(xInc)
        , yInc_(yInc)
        , width_(width)
    {
    }
 
    template <class PLANE_T, std::enable_if_t<PlaneTraits<PLANE_T>::HasVpat, int> = 0>
    static LinearAccessData FromPlaneImpl(const PLANE_T &plane) noexcept;
    template <class PLANE_T, std::enable_if_t<!PlaneTraits<PLANE_T>::HasVpat, int> = 0>
    static LinearAccessData FromPlaneImpl(const PLANE_T &plane) noexcept;
 
    std::uint8_t *basePtr_ = nullptr;  
    std::intptr_t xInc_    = 0;        
    std::intptr_t yInc_    = 0;        
    int width_             = 0;        
  };
 
  inline LinearAccessData::LinearAccessData() noexcept = default;
 
  using LinearAccess = LinearAccessData;
 
  inline bool operator!=(const LinearAccessData &lhs, const LinearAccessData &rhs) noexcept
  {
    return lhs.BasePtr() != rhs.BasePtr() || lhs.YInc() != rhs.YInc() || lhs.XInc() != rhs.XInc()
           || lhs.Width() != rhs.Width();
  }
 
  inline bool operator==(const LinearAccessData &lhs, const LinearAccessData &rhs) noexcept
  {
    return !(lhs != rhs);
  }
 
  inline bool IsInterleaved(size_t bytesPerPixel, const LinearAccessData &access0,
                            const LinearAccessData &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 LinearAccessData &) noexcept
    {
      return true;
    }
 
    struct LinearAccessFindNonInterleaved
    {
      size_t bytesPerPixel;
 
      inline bool operator()(const LinearAccessData *access0, const LinearAccessData *access1) const noexcept
      {
        return !IsInterleaved(bytesPerPixel, *access0, *access1);
      }
 
      inline bool operator()(const LinearAccessData &access0, const LinearAccessData &access1) const noexcept
      {
        return !IsInterleaved(bytesPerPixel, access0, access1);
      }
    };
  }  // namespace
 
  template <size_t I>
  bool IsInterleaved(std::size_t bytesPerPixel, const std::array<LinearAccessData, I> &accesses) noexcept
  {
    return std::adjacent_find(accesses.cbegin(), accesses.cend(), Cvb::LinearAccessFindNonInterleaved{bytesPerPixel})
           == accesses.cend();
  }
 
  template <class... ACCESSES>
  bool IsInterleaved(size_t bytesPerPixel, const LinearAccessData &access0, const LinearAccessData &access1,
                     const ACCESSES &... accs) noexcept
  {
    const std::array<const LinearAccessData *, sizeof...(accs) + 2> arr{&access0, &access1, &accs...};
    return std::adjacent_find(arr.cbegin(), arr.cend(), LinearAccessFindNonInterleaved{bytesPerPixel}) == arr.cend();
  }
 
  CVB_END_INLINE_NS
}  // namespace Cvb