singleviewdata.h

Go to the documentation of this file.

#ifndef CTL_SINGLEVIEWDATA_H
#define CTL_SINGLEVIEWDATA_H

#include "chunk2d.h"
#include "modulelayout.h"

namespace CTL {

class SingleViewData
{
private:
    template<class DataType, class NestedIteratorType>
    class PixelIterator;

public:
    typedef Chunk2D<float> ModuleData; 
    struct Dimensions;

    using iterator               = PixelIterator<SingleViewData, ModuleData::iterator>;
    using const_iterator         = PixelIterator<const SingleViewData, ModuleData::const_iterator>;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    // ctors
    explicit SingleViewData(const ModuleData::Dimensions& moduleDimensions);
    SingleViewData(uint channelsPerModule, uint rowsPerModule);
    SingleViewData(const ModuleData& moduleData);
    SingleViewData(ModuleData&& moduleData);

    // pixel iterators
    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;

    // getter methods
    const std::vector<ModuleData>& constData() const;
    const std::vector<ModuleData>& data() const;
    std::vector<ModuleData>& data();
    Dimensions dimensions() const;
    uint elementsPerModule() const;
    const ModuleData& first() const;
    ModuleData& first();
    ModuleData& module(uint i);
    const ModuleData& module(uint i) const;
    uint nbModules() const;
    size_t totalPixelCount() const;

    // other methods
    void allocateMemory(uint nbModules);
    void allocateMemory(uint nbModules, float initValue);
    void append(ModuleData&& moduleData);
    void append(const ModuleData& moduleData);
    void append(std::vector<float>&& dataVector);
    void append(const std::vector<float>& dataVector);
    Chunk2D<float> combined(const ModuleLayout& layout = ModuleLayout(), bool* ok = nullptr) const;
    void fill(float fillValue);
    void freeMemory();
    float max() const;
    float min() const;
    void setDataFromVector(const std::vector<float>& dataVector);
    SingleViewData split(const ModuleLayout& layout) const;
    std::vector<float> toVector() const;
    void transformToExtinction(double i0orN0 = 1.0);
    void transformToIntensity(double i0 = 1.0);
    void transformToCounts(double n0 = 1.0);

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

    SingleViewData& operator+=(const SingleViewData& other);
    SingleViewData& operator-=(const SingleViewData& other);
    SingleViewData& operator*=(float factor);
    SingleViewData& operator/=(float divisor);

    SingleViewData operator+(const SingleViewData& other) const;
    SingleViewData operator-(const SingleViewData& other) const;
    SingleViewData operator*(float factor) const;
    SingleViewData operator/(float divisor) const;

protected:
    ModuleData::Dimensions _moduleDim; 

    std::vector<ModuleData> _data;  

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

struct SingleViewData::Dimensions
{
    uint nbChannels; 
    uint nbRows;     
    uint nbModules;  

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

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

template<class DataType, class NestedIteratorType>
class SingleViewData::PixelIterator
{
public:
    using iterator_category = std::bidirectional_iterator_tag;
    using value_type        = typename NestedIteratorType::value_type;
    using difference_type   = std::ptrdiff_t;
    using pointer           = typename NestedIteratorType::pointer;
    using reference         = typename NestedIteratorType::reference;

    PixelIterator(DataType* viewData = nullptr, uint module = 0, uint pixel = 0);

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

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

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

    template<class DataType2, class NestedIteratorType2>
    operator PixelIterator<DataType2, NestedIteratorType2>() const;

    uint module() const;
    uint pixel() const;

private:
    DataType* _dataPtr;
    NestedIteratorType _moduleIterator;

    uint _curModule{0};

    void nextModule();
    void prevModule();
};

template<class DataType, class NestedIteratorType>
SingleViewData::PixelIterator<DataType, NestedIteratorType>::PixelIterator(DataType* viewData,
                                                                           uint module,
                                                                           uint pixel)
    : _dataPtr(viewData)
    , _curModule(module)
{
    _dataPtr = viewData;

    if(_dataPtr)
        _moduleIterator = std::next(_dataPtr->module(module).begin(), pixel);
}

template<class DataType, class NestedIteratorType>
SingleViewData::PixelIterator<DataType, NestedIteratorType>&
SingleViewData::PixelIterator<DataType, NestedIteratorType>::operator++()
{
    ++_moduleIterator;
    if(_moduleIterator == _dataPtr->module(_curModule).end())
        nextModule();

    return (*this);
}

template<class DataType, class NestedIteratorType>
SingleViewData::PixelIterator<DataType, NestedIteratorType>
SingleViewData::PixelIterator<DataType, NestedIteratorType>::operator++(int)
{
    auto temp(*this);
    ++(*this);
    return temp;
}

template<class DataType, class NestedIteratorType>
CTL::SingleViewData::PixelIterator<DataType, NestedIteratorType>&
SingleViewData::PixelIterator<DataType, NestedIteratorType>::operator--()
{
    if(_moduleIterator == _dataPtr->module(_curModule).begin())
        prevModule();

    --_moduleIterator;

    return (*this);
}

template<class DataType, class NestedIteratorType>
CTL::SingleViewData::PixelIterator<DataType, NestedIteratorType>
SingleViewData::PixelIterator<DataType, NestedIteratorType>::operator--(int)
{
    auto temp(*this);
    --(*this);
    return temp;
}

template<class DataType, class NestedIteratorType>
uint SingleViewData::PixelIterator<DataType, NestedIteratorType>::module() const
{
    return _curModule;
}

template<class DataType, class NestedIteratorType>
uint SingleViewData::PixelIterator<DataType, NestedIteratorType>::pixel() const
{
    return std::distance(_dataPtr->module(_curModule).cbegin(),
                         ModuleData::const_iterator{ _moduleIterator });
}

template<class DataType, class NestedIteratorType>
void SingleViewData::PixelIterator<DataType, NestedIteratorType>::nextModule()
{
    ++_curModule;

    if(_curModule < _dataPtr->nbModules())
        _moduleIterator = _dataPtr->module(_curModule).begin();
    else
        --_curModule;
}

template<class DataType, class NestedIteratorType>
void SingleViewData::PixelIterator<DataType, NestedIteratorType>::prevModule()
{
    --_curModule;

    if(_curModule >= 0)
        _moduleIterator = _dataPtr->module(_curModule).end();
    else
        ++_curModule;

}


} // namespace CTL

#endif // CTL_SINGLEVIEWDATA_H