pixeliterator.h

#ifndef PixelIterator_H
#define PixelIterator_H



namespace Ilwis {

class Tranquilizer;

typedef std::shared_ptr<Tranquilizer> SPTranquilizer;

class KERNELSHARED_EXPORT PixelIterator  : public std::iterator<std::random_access_iterator_tag, double> {
public:
    enum Flow { fXYZ, fYXZ, fXZY, fYZX, fZXY, fZYX};

    bool isValid() const{
        return _isValid;
    }


    PixelIterator();

    PixelIterator(const IRasterCoverage& raster, const BoundingBox& box=BoundingBox());

    PixelIterator(const PixelIterator& iter);

    PixelIterator(PixelIterator &&iter);

    PixelIterator& operator=(const PixelIterator& iter);

    PixelIterator& operator=(const PixelIterator&& iter);

    PixelIterator& operator++() {
        move(1);
        return *this;
    }

    PixelIterator& operator--() {
        move(-1);
        return *this;
    }

    PixelIterator& operator+=(int n) {
        move(n);
        return *this;
    }

    PixelIterator& operator-=(int n) {
        move(-n);
        return *this;
    }

    double& operator[](quint32 index){
        _x = 0;
        _y = 0;
        _z = 0;
        _yChanged = _xChanged = _zChanged = true;
        initPosition();
        move(index);
        return this->operator *();
    }

    QVariant operator()(const QString& column,Coverage::AttributeType attType=Coverage::atCOVERAGE);

    PixelIterator &operator ()(const Pixel &pix)
    {
        _x = pix.x;
        _y = pix.y;
        _z = pix.z;
        _yChanged = _xChanged = _zChanged = true;
        initPosition();
        return *this;
    }

    PixelIterator operator++(int);

    PixelIterator operator--(int);

    PixelIterator& operator[](const Pixel& pix){
        return operator ()(pix);
    }

    bool operator==(const PixelIterator& iter) const;

    bool operator!=(const PixelIterator& iter) const;

    bool operator<(const PixelIterator& iter) const;

    bool operator<=(const PixelIterator& iter) const;

    bool operator>(const PixelIterator& iter) const;

    bool operator>=(const PixelIterator& iter) const;

    double& operator*() {
        return _grid->value(_currentBlock, _localOffset );
    }

    const double& operator*() const {
        return  _grid->value(_currentBlock, _localOffset);
    }

    double* operator->() {
        return &(_grid->value(_currentBlock, _localOffset ));
    }

    PixelIterator end() const ;

    void setFlow(Flow flw);

    bool contains(const Pixel& pix) ;

    bool xchanged() const;

    bool ychanged() const;

    bool zchanged() const;

    bool isAtEnd() const {
        return _x == _endx &&
               _y == _endy &&
               _z == _endz;
    }

    Pixel position() const;

    const BoundingBox& box() const;

    quint32 linearPosition() const;

    int operator -(const PixelIterator &iter2);

    PixelIterator operator+(int n) {
        PixelIterator iter(*this);
        iter.move(n);
        return iter;
    }

    void setTranquilizer(const SPTranquilizer& trq) {
        _trq = trq;
    }

protected:
    PixelIterator(quint64 endpos ) :
        _grid(0),
        _x(0),
        _y(0),
        _z(0),
        _localOffset(0),
        _currentBlock(0),
        _flow(fXYZ),
        _isValid(true),
        _endx(0),
        _endy(0),
        _endz(0),
        _linearposition(endpos),
        _endposition(endpos),
        _xChanged(false),
        _yChanged(false),
        _zChanged(false)
    {
    }

    void init();
    void initPosition();
    //bool move(int n);
    //bool moveXYZ(int delta) ;
    void copy(const PixelIterator& iter);

    IRasterCoverage _raster;
    Grid *_grid = 0;
    BoundingBox _box;
    qint32 _x = 0;
    qint32 _y = 0;
    qint32 _z = 0;
    qint32 _localOffset = 0;
    qint32 _currentBlock = 0;
    Flow _flow;
    bool _isValid;
    qint32 _endx;
    qint32 _endy;
    qint32 _endz;
    quint64 _linearposition;
    quint64 _endposition;
    bool _xChanged =false;
    bool _yChanged = false;
    bool _zChanged = false;
    SPTranquilizer _trq;


    bool move(int n) {

        bool ok = false;
        if (isAtEnd()) {
            _linearposition = _endposition;
            return false;
        }
        if ( _flow == fXYZ) {
            ok = moveXYZ(n);
        }
        else if ( _flow == fYXZ){
        }

        return ok;
    }


private:
    bool moveXYZ(int delta) {
        _x += delta;
        _linearposition += delta;
        _localOffset += delta;
        _xChanged = true;
        _yChanged = _zChanged = false;

        if ( _x > _endx) {
            return moveYZ(delta);
        }
        return true;
    }

    bool moveYZ(int delta);
};

inline Ilwis::PixelIterator begin(const Ilwis::IRasterCoverage& raster) {
    return PixelIterator(raster);
}

inline Ilwis::PixelIterator end(const Ilwis::IRasterCoverage& raster) {
    PixelIterator iter(raster);
    return iter.end();
}

}
#endif // PixelIterator_H