ScopeImage.h

#pragma once

#include "pixel.h"
#include "DaqChunk.h"
#include "ScopeException.h"
#include "helpers.h"

namespace scope {

template<class T>
class ScopeImageAccess;

template<class T>
class ScopeImageConstAccess;

template<class T>
class ScopeImage {

    friend ScopeImageAccess<T>; 

    friend ScopeImageConstAccess<T>;

public:
    typedef std::pair<typename std::vector<T>::iterator, typename std::vector<T>::iterator> datapart_t;

    typename typedef std::vector<T>::const_iterator citerator;

    typename typedef std::vector<T>::size_type size_type;

protected:
    const uint32_t area;

    uint32_t lines;

    uint32_t linewidth;

    bool complete_frame;

    bool complete_avg;

    double percent_complete;

    std::vector<T> data;

    typename std::vector<T>::iterator inserter;

    datapart_t newpart;

    mutable std::mutex pixelmutex;

    mutable std::atomic<int16_t> reading_access;

    mutable std::condition_variable readcond;

public:
    ScopeImage(const uint32_t& _lines = 128, const uint32_t& _linewidth = 128, const uint32_t& _area = 0, const bool& _complete_avg = false, const bool& _complete_frame = false)
        : area(_area)
        , lines(_lines)
        , linewidth(_linewidth)
        , complete_frame(_complete_frame)
        , percent_complete(0.0)
        , complete_avg(_complete_avg)
        , data(_lines*_linewidth, T(0))
        , inserter(data.begin())
        , newpart(data.begin(), data.begin())
        , reading_access(0) {
    }

    ScopeImage(const ScopeImage& _si)
        : area(_si.area)
        , lines(_si.lines)
        , linewidth(_si.linewidth)
        , complete_frame(_si.complete_frame)
        , percent_complete(_si.percent_complete)
        , complete_avg(_si.complete_avg)
        , reading_access(0) {
        ScopeImageConstAccess<T> acc(_si);
        data = *acc.GetConstData();
        inserter = data.begin();
        newpart = datapart_t(data.begin(), data.begin());
    }

    ScopeImage& operator=(const ScopeImage& _si) {
        // Avoid self-assignment
        if ( this != &_si ) {
            assert(lines == _si.lines);
            assert(linewidth == _si.linewidth);
            area = _si.area;
            complete_frame = _si.complete_frame;
            percent_complete = _si.percent_complete;
            complete_avg = _si.complete_avg;
            ScopeImageAccess<T> acc(_si);
            data = *acc.GetData();
            inserter = data.begin();
            newpart = datapart_t(data.begin(), data.begin());
        }
        return *this;
    }

    uint32_t Area() const { return area; }
    uint32_t Lines() const { return lines; }
    uint32_t Linewidth() const { return linewidth; }
    datapart_t Newpart() const { return newpart; }
    bool IsCompleteFrame() const { return complete_frame; }
    double PercentComplete() const { return percent_complete; }
    bool IsCompleteAvg() const { return complete_avg; }
    void SetCompleteFrame(const bool& _complete) { complete_frame = _complete; }
    void SetPercentComplete(const double& _percent) { percent_complete = _percent; }
    void SetCompleteAvg(const bool& _complete) { complete_avg = _complete; }
    T Pixel (const uint32_t& _column, const uint32_t& _line) const {
        ScopeImageConstAccess<T> acc(*this);
        return acc.GetConstData()->at(_line * linewidth + _column);
    }

    void FillRandom() {
        std::lock_guard<std::mutex> lock(pixelmutex);
        std::mt19937 mt;
        mt.seed(static_cast<unsigned long>(GetTickCount64()));
        std::generate( std::begin(data), std::end(data), mt);
        newpart = std::make_pair(data.begin(), data.end());
    }

protected:
    std::vector<T>* GetData() {
        std::unique_lock<std::mutex> lock(pixelmutex);
        while ( reading_access > 0 )
            readcond.wait(lock);
        lock.release();         // mutex stays locked
        return &data;
    }

    const std::vector<T>* GetDataConst() const {
        pixelmutex.lock();              // waits until a write access is finished
        reading_access++;
        pixelmutex.unlock();
        return &data;
    }

    void ReleaseData() {
        pixelmutex.unlock();
    }

    void ReleaseDataConst() const {
        assert(reading_access > 0);
        reading_access--;
        readcond.notify_all();
    }
};

template<class T>
class ScopeImageAccess {
protected:
    ScopeImage<T>* const image;
    std::vector<T>* const pData;

public:
    ScopeImageAccess(ScopeImage<T>& _image)
        : image(&_image)
        , pData(image->GetData()) {
    }

    ~ScopeImageAccess() {
        image->ReleaseData();
    }
    
    std::vector<T>* GetData() const {
        return pData;
    }

    T* GetPointer() const {
        return pData->data();
    }
};

template<class T>
class ScopeImageConstAccess {
protected:
    const ScopeImage<T>* const image;
    const std::vector<T>* const pData;

public:
    ScopeImageConstAccess(const ScopeImage<T>& _image)
    : image(&_image)
    , pData(image->GetDataConst()) {
    }

    ~ScopeImageConstAccess() {
        image->ReleaseDataConst();
    }
    
    const std::vector<T>* GetConstData() const {
        return pData;
    }
};

typedef std::shared_ptr<ScopeImage<uint16_t>> ScopeImageU16Ptr;
typedef std::shared_ptr<const ScopeImage<uint16_t>> ScopeImageU16CPtr;
typedef ScopeImageAccess<uint16_t> ScopeImageAccessU16;
typedef ScopeImageConstAccess<uint16_t> ScopeImageConstAccessU16;

bool InsertPixels(ScopeImageU16Ptr const _img, std::vector<uint16_t>::iterator& _where, const DaqChunk::iterator& _from, const DaqChunk::iterator& _to);

bool InsertAndAveragePixels(ScopeImageU16Ptr const _img, std::vector<uint16_t>::iterator& _where, const DaqChunk::iterator _from, const DaqChunk::iterator _to, const uint16_t& _currentavgcount);

}