chunk2d.h

Go to the documentation of this file.

#ifndef CTL_CHUNK2D_H
#define CTL_CHUNK2D_H

#include "mat/matrix.h"
#include "processing/coordinates.h"
#include <QtGlobal>
#include <algorithm>
#include <array>
#include <stdexcept>
#include <string>
#include <vector>

namespace CTL {

struct Chunk2DDimensions
{
    uint width; 
    uint height; 

    bool operator==(const Chunk2DDimensions& other) const;
    bool operator!=(const Chunk2DDimensions& other) const;

    std::string info() const;
    size_t totalNbElements() const;
};

template <typename T>
class Chunk2D
{
private:
    template <class IteratorType>
    class PixelIterator;

public:
    using Dimensions = Chunk2DDimensions;

    using iterator               = PixelIterator<typename std::vector<T>::iterator>;
    using const_iterator         = PixelIterator<typename std::vector<T>::const_iterator>;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    iterator begin();
    iterator end();
    const_iterator begin() const;
    const_iterator end() const;
    const_iterator cbegin() const;
    const_iterator cend() const;
    reverse_iterator rbegin();
    reverse_iterator rend();
    const_reverse_iterator rbegin() const;
    const_reverse_iterator rend() const;
    const_reverse_iterator crbegin() const;
    const_reverse_iterator crend() const;

    // ctors
    explicit Chunk2D(const Dimensions& dimensions);
    Chunk2D(const Dimensions& dimensions, const T& initValue);
    Chunk2D(const Dimensions& dimensions, std::vector<T>&& data);
    Chunk2D(const Dimensions& dimensions, const std::vector<T>& data);

    Chunk2D(uint width, uint height);
    Chunk2D(uint width, uint height, const T& initValue);
    Chunk2D(uint width, uint height, std::vector<T>&& data);
    Chunk2D(uint width, uint height, const std::vector<T>& data);

    // getter methods
    size_t allocatedElements() const;
    const std::vector<T>& constData() const;
    const std::vector<T>& data() const;
    bool hasData() const;

    const Dimensions& dimensions() const;
    uint height() const;
    T max() const;
    T min() const;
    size_t nbElements() const;
    T* rawData();
    const T* rawData() const;
    uint width() const;

    typename std::vector<T>::reference operator()(uint x, uint y);
    typename std::vector<T>::const_reference operator()(uint x, uint y) const;

    bool operator==(const Chunk2D<T>& other) const;
    bool operator!=(const Chunk2D<T>& other) const;

    Chunk2D& operator+=(const Chunk2D<T>& other);
    Chunk2D& operator-=(const Chunk2D<T>& other);
    Chunk2D& operator*=(const T& factor);
    Chunk2D& operator/=(const T& divisor);

    Chunk2D operator+(const Chunk2D<T>& other) const;
    Chunk2D operator-(const Chunk2D<T>& other) const;
    Chunk2D operator*(const T& factor) const;
    Chunk2D operator/(const T& divisor) const;

    // setter methods
    void setData(std::vector<T>&& data);
    void setData(const std::vector<T>& data);

    // other methods
    void allocateMemory();
    void allocateMemory(const T& initValue);
    void fill(const T& fillValue);
    void freeMemory();

protected:
    std::vector<T> _data; 
    Dimensions _dim; 

private:
    bool hasEqualSizeAs(const std::vector<T>& other) const;
};

struct PixelIndex : Generic2DIndex
{
    using Generic2DIndex::Generic2DIndex;

    uint& x() { return idx1(); }
    uint& y() { return idx2(); }
    const uint& x() const { return idx1(); }
    const uint& y() const { return idx2(); }
};

// iterators
template <class T>
template <class IteratorType>
class Chunk2D<T>::PixelIterator
{
public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type        = typename IteratorType::value_type;
    using difference_type   = typename IteratorType::difference_type;
    using pointer           = typename IteratorType::pointer;
    using reference         = typename IteratorType::reference;

    PixelIterator(IteratorType voxel = {}, const Chunk2D<T>* ptrToVol = nullptr);

    friend bool operator==(const PixelIterator& left, const PixelIterator& right)
    {
        return left._dataItr == right._dataItr;
    }
    friend bool operator!=(const PixelIterator& left, const PixelIterator& right)
    {
        return left._dataItr != right._dataItr;
    }

    PixelIterator& operator++();
    PixelIterator  operator++(int);
    PixelIterator& operator--();
    PixelIterator  operator--(int);

    reference operator*() const { return *_dataItr; }
    pointer   operator->() const { return _dataItr.operator->(); }

    operator PixelIterator<typename std::vector<T>::const_iterator>() const;

    reference value() const;
    PixelIndex pixelIndex() const;

private:
    IteratorType _dataItr;
    const Chunk2D<T>* _ptrToVol;
};

namespace assist {

template <typename ToType, typename FromType, typename ConversionFun = ToType (*)(const FromType&)>
Chunk2D<ToType> convertTo(const Chunk2D<FromType>& chunk2d,
                          ConversionFun f = [](const FromType& val) { return static_cast<ToType>(val); });
float interpolate2D(const Chunk2D<float>& chunk2D, const mat::Matrix<2,1>& pos);
float interpolate2D(const Chunk2D<float>& chunk2D, double x, double y);

} // namespace assist

using assist::convertTo;

} // namespace CTL

#include "chunk2d.tpp"

#endif // CTL_CHUNK2D_H