ImageBuffer.hpp

/*
 *  Copyright 2011, 2012 Lukas Jirkovsky
 *
 *  This file is part of FotoSHOCKcore.
 *
 *  FotoSHOCKcore is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, version 3 of the License.
 *
 *  FotoSHOCKcore is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with FotoSHOCKcore.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef IMAGEBUFFER_H
#define IMAGEBUFFER_H

#include "ImageBufferBase.hpp"
#include "Tile.hpp"

#include <cmath>

namespace FotoSHOCKcore{

// Forward declaration to make iterator available to ImageBuffer declaration
template <ValueType::Enum PixelFormat> class ImageBufferIterator;


template <ValueType::Enum PixelFormat>
class ImageBuffer : public ImageBufferBase {
    public:
        friend class ImageBufferIterator<PixelFormat>;
        

        ImageBuffer(unsigned int width, unsigned int height, PixelData pixelData, unsigned int tileExtent, bool allocateTiles = true);

        // TODO: throw an exception in case of error
        ImageBuffer(const ImageBuffer<PixelFormat> &other);

        virtual ~ImageBuffer();


        ImageBuffer<PixelFormat>& operator= (const ImageBuffer<PixelFormat> &other);


        void setStamp (long stamp);


        Tile<PixelFormat>* getTile(unsigned int horizontal, unsigned int vertical);

        Tile<PixelFormat>* getTileFromPos(unsigned int x, unsigned int y);


        typedef ImageBufferIterator<PixelFormat> Iterator;

        // NOTE: all iterator related functions are defined AFTER the ImageBufferIterator definition

        Iterator upperLeft();

        Iterator lowerRight();

        Iterator getIterator(unsigned int x, unsigned int y);
    private:
        Tile<PixelFormat> ***m_tileGrid;
};

template <ValueType::Enum PixelFormat>
ImageBuffer<PixelFormat>::ImageBuffer (unsigned int width, unsigned int height, PixelData pixelData, unsigned int tileExtent, bool allocateTiles) {
    // ensure that the tileExtent is power of two
    assert((tileExtent & (tileExtent - 1)) == 0);
    
    m_width = width;
    m_height = height;
    m_tileExtent = tileExtent;
    m_numOfTilesHorizontal = std::ceil((double) width/(double) tileExtent);
    m_numOfTilesVertical = std::ceil((double) height/(double) tileExtent);
    m_pixelData = pixelData;
    
    m_tileGrid = new Tile<PixelFormat>** [m_numOfTilesVertical+1];
    for (unsigned int i = 0; i < m_numOfTilesVertical; i++) {
        m_tileGrid[i] = new Tile<PixelFormat>* [m_numOfTilesHorizontal];
        for (unsigned int j = 0; j < m_numOfTilesHorizontal; j++) {
            if (allocateTiles) {
                m_tileGrid[i][j] = new Tile<PixelFormat>(m_tileExtent, m_pixelData.numOfBands());
            } else {
                m_tileGrid[i][j] = 0;
            }
        }
    }
    // Add one small tile after the last valid tilewhich acts as a sentinel
    // This tile is used with ImageBufferIterator and lowerRight()
    m_tileGrid[m_numOfTilesVertical] = new Tile<PixelFormat>* [1];
    m_tileGrid[m_numOfTilesVertical][0] = new Tile<PixelFormat>(1, m_pixelData.numOfBands());
}

template <ValueType::Enum PixelFormat>
ImageBuffer<PixelFormat>::ImageBuffer(const ImageBuffer<PixelFormat>& other): ImageBufferBase(other) {
    m_width = other.m_width;
    m_height = other.m_height;
    m_tileExtent = other.m_tileExtent;
    m_numOfTilesHorizontal = other.m_numOfTilesHorizontal;
    m_numOfTilesVertical = other.m_numOfTilesVertical;
    m_pixelData = other.m_pixelData;

    m_tileGrid = new Tile<PixelFormat>** [m_numOfTilesVertical+1];
    for (unsigned int i = 0; i < m_numOfTilesVertical; i++) {
        m_tileGrid[i] = new Tile<PixelFormat>* [m_numOfTilesHorizontal];
        for (unsigned int j = 0; j < m_numOfTilesHorizontal; j++) {
            if (other.m_tileGrid[i][j]) {
                m_tileGrid[i][j] = new Tile<PixelFormat>(*(other.m_tileGrid[i][j]));
            } else {
                m_tileGrid[i][j] = 0;
            }
        }
    }
    // Add one small tile after the last valid tile, which acts as a sentinel
    // This tile is used with ImageBufferIterator and lowerRight()
    m_tileGrid[m_numOfTilesVertical] = new Tile<PixelFormat>* [1];
    m_tileGrid[m_numOfTilesVertical][0] = new Tile<PixelFormat>(1, m_pixelData.numOfBands());
}

template <ValueType::Enum PixelFormat>
ImageBuffer<PixelFormat>::~ImageBuffer() {
    for (unsigned int i = 0; i < m_numOfTilesVertical; i++) {
        // free all allocated tiles
        for (unsigned int j = 0; j < m_numOfTilesHorizontal; j++) {
            if (m_tileGrid[i][j]) {
                delete m_tileGrid[i][j];
            }
        }
        // free the row
        delete[] m_tileGrid[i];
    }
    // delete the sentinel
    delete m_tileGrid[m_numOfTilesVertical][0];
    delete[] m_tileGrid[m_numOfTilesVertical];
    // delete the grid
    delete[] m_tileGrid;
}

template <ValueType::Enum PixelFormat>
ImageBuffer<PixelFormat>& ImageBuffer<PixelFormat>::operator=(const ImageBuffer<PixelFormat>& other) {
    if (this != &other) {
        if (m_width == other.m_width && m_height == other.m_height &&
            m_tileExtent == other.m_tileExtent && m_pixelData.numOfBands() == other.m_pixelData.numOfBands())
        {
            // we can use the tile copy operator to copy the Tile content directly
            // because it does only memcpy in this case, it should be exception-safe
            for (unsigned int i = 0; i < m_numOfTilesVertical; i++) {
                for (unsigned int j = 0; j < m_numOfTilesHorizontal; j++) {
                    if (other.m_tileGrid[i][j]) {
                        *m_tileGrid[i][j] = *(other.m_tileGrid[i][j]);
                    } else {
                        m_tileGrid[i][j] = 0;
                    }
                }
            }
            // even though the Tile data was be copied directly, the PixelData may be different
            // (eg. only colorspace is different), so copy PixelData too
            m_pixelData = other.m_pixelData;
        } else {
            // uses copy constructor and std::swap to make the operator= exception safe
            ImageBuffer<PixelFormat> tmp(other);

            std::swap(m_width, tmp.m_width);
            std::swap(m_height, tmp.m_height);
            std::swap(m_tileExtent, tmp.m_tileExtent);
            std::swap(m_numOfTilesHorizontal, tmp.m_numOfTilesHorizontal);
            std::swap(m_numOfTilesVertical, tmp.m_numOfTilesVertical);
            std::swap(m_pixelData, tmp.m_pixelData);
            std::swap(m_tileGrid, tmp.m_tileGrid);
        }
    }

    return *this;
}

template <ValueType::Enum PixelFormat>
void ImageBuffer<PixelFormat>::setStamp(long stamp) {
    for (unsigned int i = 0; i < m_numOfTilesVertical; i++) {
        for (unsigned int j = 0; j < m_numOfTilesHorizontal; j++) {
            if (m_tileGrid[i][j]) {
                m_tileGrid[i][j]->setStamp(stamp);
            }
        }
    }
}

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>* ImageBuffer<PixelFormat>::getTile(unsigned int horizontal, unsigned int vertical) {
    if (m_tileGrid[vertical][horizontal] == 0) {
        m_tileGrid[vertical][horizontal] = new Tile<PixelFormat>(m_tileExtent, m_pixelData.numOfBands());
    }
    return m_tileGrid[vertical][horizontal];
}

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>* ImageBuffer<PixelFormat>::getTileFromPos(unsigned int x, unsigned int y) {
    // get the position in the tile grid
    unsigned int horiz = x / m_tileExtent;
    unsigned int vert = y / m_tileExtent;

    if (m_tileGrid[vert][horiz] == 0) {
        m_tileGrid[vert][horiz] = new Tile<PixelFormat>(m_tileExtent, m_pixelData.numOfBands());
    }
    return m_tileGrid[vert][horiz];
}


template <ValueType::Enum PixelFormat>
class ImageBufferIterator{
    public:
        typedef typename ValueTypeInfo<PixelFormat>::Type format;


        ImageBufferIterator(ImageBuffer<PixelFormat>* buffer);

        ImageBufferIterator(const ImageBufferIterator<PixelFormat> &other);
        ~ImageBufferIterator();


        ImageBufferIterator<PixelFormat>& operator= (const ImageBufferIterator<PixelFormat> &other);


        bool operator==(const ImageBufferIterator<PixelFormat> &other) const;

        bool operator!=(const ImageBufferIterator<PixelFormat> &other) const;


        ImageBufferIterator<PixelFormat>& operator++();

        ImageBufferIterator<PixelFormat>& operator--();

        ImageBufferIterator<PixelFormat>& moveTo(unsigned int x, unsigned int y);


        format* operator*();

        const format* operator*() const;


        format* operator()(unsigned int x, unsigned int y);

        const format* operator()(unsigned int x, unsigned int y) const;


        format& operator[](unsigned int n);

        const format operator[](unsigned int n) const;


        format getValue(unsigned int band) const;

        void setValue(unsigned int band, format value);


        const unsigned int getX() const;

        const unsigned int getY() const;
    private:
        typedef typename Tile<PixelFormat>::Iterator TileIterator;

        TileIterator** m_tileIteratorGrid;
        TileIterator* m_currentIterator;

        unsigned int m_currentTileHorizPos;
        unsigned int m_currentTileVertPos;
        unsigned int m_currentXoffset;
        unsigned int m_currentYoffset;
        unsigned int m_currentXpos;
        unsigned int m_currentYpos;

        unsigned int m_width;
        unsigned int m_tileExtent;
        unsigned int m_power; // stores the n from "2^n = m_tileExtent"

        // number of tiles in each dimension
        unsigned int m_horiz;
        unsigned int m_vert;
};

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>::ImageBufferIterator(ImageBuffer< PixelFormat >* buffer) {
    // allocate TileIterator grid
    m_horiz = buffer->getNumOfTilesHoriz();
    m_vert = buffer->getNumOfTilesVert();
    // make the space for one iterator after the last valid iterator to make lowerRight() working
    m_tileIteratorGrid = new TileIterator* [m_vert+1];
    for (unsigned int i = 0; i < m_vert; i++) {
        m_tileIteratorGrid[i] = new TileIterator[m_horiz];
        for (unsigned int j = 0; j < m_horiz; j++) {
            m_tileIteratorGrid[i][j] = buffer->getTile(j, i)->upperLeft();
        }
    }
    // add sentinel
    m_tileIteratorGrid[m_vert] = new TileIterator [1];
    m_tileIteratorGrid[m_vert][0] = buffer->getTile(0, m_vert)->upperLeft();

    // set dimensions
    m_width = buffer->getWidth();
    m_tileExtent = buffer->m_tileExtent;
    // find which power of the the tileExtent is
    m_power = 0;
    for (unsigned int tmp = m_tileExtent; tmp > 1; tmp >>= 1) {
        m_power++;
    }

    // set the iterator to the first pixel of a first Tile
    m_currentIterator = &m_tileIteratorGrid[0][0];
    m_currentTileHorizPos = 0;
    m_currentTileVertPos = 0;
    m_currentXoffset = 0;
    m_currentYoffset = 0;
    m_currentXpos = 0;
    m_currentYpos = 0;
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>::ImageBufferIterator(const ImageBufferIterator<PixelFormat>& other) {
    // allocate TileIterator grid
    m_horiz = other.m_horiz;
    m_vert = other.m_vert;
    // make the space for one iterator after the last valid iterator to make lowerRight() working
    m_tileIteratorGrid = new TileIterator* [m_vert+1];
    for (unsigned int i = 0; i < m_vert; i++) {
        m_tileIteratorGrid[i] = new TileIterator[m_horiz];
        for (unsigned int j = 0; j < m_horiz; j++) {
            m_tileIteratorGrid[i][j] = TileIterator(other.m_tileIteratorGrid[i][j]);
        }
    }
    // add sentinel
    m_tileIteratorGrid[m_vert] = new TileIterator [1];
    m_tileIteratorGrid[m_vert][0] = TileIterator(other.m_tileIteratorGrid[m_vert][0]);

    // set dimensions
    m_width = other.m_width;
    m_tileExtent = other.m_tileExtent;
    m_power = other.m_power;

    m_currentTileHorizPos = other.m_currentTileHorizPos;
    m_currentTileVertPos = other.m_currentTileVertPos;
    m_currentXoffset = other.m_currentXoffset;
    m_currentYoffset = other.m_currentYoffset;
    m_currentXpos = other.m_currentXpos;
    m_currentYpos = other.m_currentYpos;
    // set the current iterator to a correct place
    m_currentIterator = &m_tileIteratorGrid[m_currentTileVertPos][m_currentTileHorizPos];
    m_currentIterator->moveTo(m_currentXoffset, m_currentYoffset);
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>::~ImageBufferIterator() {
    for (unsigned int i = 0; i < m_vert; i++) {
        delete[] m_tileIteratorGrid[i];
    }
    // delete sentinel
    delete[] m_tileIteratorGrid[m_vert];
    // delete the grid
    delete[] m_tileIteratorGrid;
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>& ImageBufferIterator<PixelFormat>::operator=(const ImageBufferIterator<PixelFormat>& other) {
    if (this != &other) {
        ImageBufferIterator<PixelFormat> tmp(other);

        std::swap(m_horiz, tmp.m_horiz);
        std::swap(m_vert, tmp.m_vert);
        std::swap(m_tileIteratorGrid, tmp.m_tileIteratorGrid);
        std::swap(m_width, tmp.m_width);
        std::swap(m_tileExtent, tmp.m_tileExtent);
        std::swap(m_power, tmp.m_power);
        std::swap(m_currentIterator, tmp.m_currentIterator);
        std::swap(m_currentTileHorizPos, tmp.m_currentTileHorizPos);
        std::swap(m_currentTileVertPos, tmp.m_currentTileVertPos);
        std::swap(m_currentXoffset, tmp.m_currentXoffset);
        std::swap(m_currentYoffset, tmp.m_currentYoffset);
        std::swap(m_currentXpos, tmp.m_currentXpos);
        std::swap(m_currentYpos, tmp.m_currentYpos);
    }

    return *this;
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>& ImageBufferIterator<PixelFormat>::operator++() {
    m_currentXoffset++;
    m_currentXpos++;
    if (m_currentXpos >= m_width) {
        // move to the next line
        m_currentTileHorizPos = 0;
        m_currentXoffset = 0;

        m_currentXpos = 0;
        m_currentYpos++;

        m_currentYoffset++;

        // move to the next row of tiles
        if (m_currentYoffset >= m_tileExtent) {
            m_currentYoffset = 0;
            m_currentTileVertPos++;
        }
        m_currentIterator = &m_tileIteratorGrid[m_currentTileVertPos][m_currentTileHorizPos];
        m_currentIterator->moveTo(m_currentXoffset, m_currentYoffset);
    } else if (m_currentXoffset >= m_tileExtent) {
        m_currentTileHorizPos++;
        // move to the next tile
        m_currentXoffset = 0;

        m_currentIterator = &m_tileIteratorGrid[m_currentTileVertPos][m_currentTileHorizPos];
        m_currentIterator->moveTo(m_currentXoffset, m_currentYoffset);
    } else {
        ++(*m_currentIterator);
    }
    
    return *this;
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>& ImageBufferIterator<PixelFormat>::operator--() {
    // I'm in the leftmost position of a Tile
    if (m_currentXoffset == 0) {
        // I'm in the leftmost Tile
        if (m_currentTileHorizPos == 0) {
            m_currentXoffset = (m_width - 1) & (m_tileExtent - 1);
            m_currentTileHorizPos = m_horiz - 1;
            m_currentXpos = m_width - 1;
            m_currentYpos--;

            if (m_currentYoffset == 0) {
                if (m_currentTileVertPos != 0) {
                    // move to the previous row
                    m_currentTileVertPos--;
                    m_currentYoffset = m_tileExtent - 1;
                }
            } else {
                // move to the previous row of Tiles
                m_currentYoffset--;
            }
        } else {
            m_currentXoffset = m_tileExtent - 1;
            m_currentXpos--;
            m_currentTileHorizPos--;
        }

        m_currentIterator = &m_tileIteratorGrid[m_currentTileVertPos][m_currentTileHorizPos];
        m_currentIterator->moveTo(m_currentXoffset, m_currentYoffset);
    } else {
        m_currentXpos--;
        m_currentXoffset--;
        --(*m_currentIterator);
    }
    
    return *this;
}

template <ValueType::Enum PixelFormat>
ImageBufferIterator<PixelFormat>& ImageBufferIterator<PixelFormat>::moveTo(unsigned int x, unsigned int y) {
    // NOTE: this might be improved that in the case of a small movement there is no division
    m_currentTileHorizPos = x >> m_power;
    m_currentTileVertPos = y >> m_power;
    m_currentXoffset = x & (m_tileExtent - 1);
    m_currentYoffset = y & (m_tileExtent - 1);
    m_currentXpos = x;
    m_currentYpos = y;

    m_currentIterator = &m_tileIteratorGrid[m_currentTileVertPos][m_currentTileHorizPos];
    m_currentIterator->moveTo(m_currentXoffset, m_currentYoffset);
    
    return *this;
}

template <ValueType::Enum PixelFormat>
typename ImageBufferIterator<PixelFormat>::format* ImageBufferIterator<PixelFormat>::operator*() {
    return **m_currentIterator;
}

template <ValueType::Enum PixelFormat>
const typename ImageBufferIterator<PixelFormat>::format* ImageBufferIterator<PixelFormat>::operator*() const {
    return **m_currentIterator;
}

template <ValueType::Enum PixelFormat>
typename ImageBufferIterator<PixelFormat>::format* ImageBufferIterator<PixelFormat>::operator()(unsigned int x, unsigned int y) {
    unsigned int tileHorizPos = x >> m_power;
    unsigned int tileVertPos = y >> m_power;
    unsigned int Xoffset = x & (m_tileExtent - 1);
    unsigned int Yoffset = y & (m_tileExtent - 1);

    return m_tileIteratorGrid[tileVertPos][tileHorizPos].operator()(Xoffset, Yoffset);
}

template <ValueType::Enum PixelFormat>
const typename ImageBufferIterator<PixelFormat>::format* ImageBufferIterator<PixelFormat>::operator()(unsigned int x, unsigned int y) const {
    unsigned int tileHorizPos = x >> m_power;
    unsigned int tileVertPos = y >> m_power;
    unsigned int Xoffset = x & (m_tileExtent - 1);
    unsigned int Yoffset = y & (m_tileExtent - 1);

    return m_tileIteratorGrid[tileVertPos][tileHorizPos].operator()(Xoffset, Yoffset);
}

template <ValueType::Enum PixelFormat>
typename ImageBufferIterator<PixelFormat>::format& ImageBufferIterator<PixelFormat>::operator[](unsigned int n) {
    return (*m_currentIterator)[n];
}

template <ValueType::Enum PixelFormat>
const typename ImageBufferIterator<PixelFormat>::format ImageBufferIterator<PixelFormat>::operator[](unsigned int n) const {
    return (*m_currentIterator)[n];
}

template <ValueType::Enum PixelFormat>
typename ImageBufferIterator<PixelFormat>::format ImageBufferIterator<PixelFormat>::getValue(unsigned int band) const {
    return m_currentIterator->getValue(band);
}

template <ValueType::Enum PixelFormat>
void ImageBufferIterator<PixelFormat>::setValue(unsigned int band, typename ImageBufferIterator<PixelFormat>::format value) {
    m_currentIterator->setValue(band, value);
}


template <ValueType::Enum PixelFormat>
const unsigned int ImageBufferIterator<PixelFormat>::getX() const {
    return m_currentXpos;
}

template <ValueType::Enum PixelFormat>
const unsigned int ImageBufferIterator<PixelFormat>::getY() const {
    return m_currentYpos;
}

template <ValueType::Enum PixelFormat>
bool ImageBufferIterator<PixelFormat>::operator==(const ImageBufferIterator< PixelFormat >& other) const {
    return *m_currentIterator == *(other.m_currentIterator);
}

template <ValueType::Enum PixelFormat>
bool ImageBufferIterator<PixelFormat>::operator!=(const ImageBufferIterator< PixelFormat >& other) const {
    return *m_currentIterator != *(other.m_currentIterator);
}


template <ValueType::Enum PixelFormat>
typename ImageBuffer<PixelFormat>::Iterator ImageBuffer<PixelFormat>::upperLeft() {
    return ImageBufferIterator<PixelFormat>(this);
}

template <ValueType::Enum PixelFormat>
typename ImageBuffer<PixelFormat>::Iterator ImageBuffer<PixelFormat>::lowerRight() {
    ImageBufferIterator<PixelFormat> iterator(this);
    // move to the pixel after the last valid pixel
    iterator.moveTo(0, m_height);
    return iterator;
}

template <ValueType::Enum PixelFormat>
typename ImageBuffer<PixelFormat>::Iterator ImageBuffer<PixelFormat>::getIterator(unsigned int x, unsigned int y) {
    ImageBufferIterator<PixelFormat> iterator(this);
    iterator.moveTo(x, y);
    return iterator;
}

}

#endif