Tile.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 TILE_H
#define TILE_H

#include "ValueType.hpp"

#include <cassert>
#include <cstring>
#include <algorithm>
#include <new>

using std::bad_alloc;
using std::ptrdiff_t;

namespace FotoSHOCKcore{

// Forward declaration to make iterator available to Tile declaration
template <ValueType::Enum PixelFormat> class TileIterator;
// Forward declaration to allow making ImageBufferIterator a frined of TileIterator
template <ValueType::Enum PixelFormat> class ImageBufferIterator;


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


        Tile (unsigned int extent, unsigned int bands) throw (bad_alloc);

        Tile (const Tile<PixelFormat> &other) throw (bad_alloc);

        virtual ~Tile();
        

        Tile<PixelFormat>& operator= (const Tile<PixelFormat> &other) throw (bad_alloc);


        void setStamp (long stamp);

        const long getStamp() const;

        typedef TileIterator<PixelFormat> Iterator;

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

        Iterator upperLeft();

        Iterator lowerRight();

        Iterator getIterator (unsigned int x = 0, unsigned int y = 0);
    private:
        format* m_data;

        unsigned int m_extent;
        unsigned int m_bands;
        long m_stamp;
};

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>::Tile (unsigned int extent, unsigned int bands) throw (bad_alloc) {
    // allocate position for an additional pixel to make the lowerRight iterator safe
    m_data = new format[(extent * extent + 1) * bands]();
    if (m_data == 0) {
        throw bad_alloc();
    }
    
    m_extent = extent;
    m_bands = bands;
    m_stamp = -1;
}

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>::Tile (const Tile<PixelFormat> &other) throw (bad_alloc) {
    size_t dataLength = other.m_extent * other.m_extent * other.m_bands;
    m_data = new format[dataLength];
    if (m_data == 0) {
        throw bad_alloc();
    }
    std::memcpy(m_data, other.m_data, dataLength  * sizeof (format));
    
    m_extent = other.m_extent;
    m_bands = other.m_bands;
    m_stamp = other.m_stamp;
}

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>::~Tile() {
    if (m_data)
        delete[] m_data;
}

template <ValueType::Enum PixelFormat>
Tile<PixelFormat>& Tile<PixelFormat>::operator= (const Tile<PixelFormat>& other) throw (bad_alloc) {
    if (this != &other) {
        if (m_extent == other.m_extent && m_bands == other.m_bands) {
            std::memcpy(m_data, other.m_data, m_extent * m_extent * m_bands * sizeof (format));
            m_stamp = other.m_stamp;
        } else {
            // uses copy constructor and std::swap to make the operator= exception safe
            Tile<PixelFormat> tmp(other);

            std::swap(m_data, tmp.m_data);
            std::swap(m_extent, tmp.m_extent);
            std::swap(m_bands, tmp.m_bands);
            std::swap(m_stamp, tmp.m_stamp);
        }
    }
    
    return *this;
}


template <ValueType::Enum PixelFormat>
void Tile<PixelFormat>::setStamp (long stamp) {
    m_stamp = stamp;
}

template <ValueType::Enum PixelFormat>
const long Tile<PixelFormat>::getStamp() const {
    return m_stamp;
}


template <ValueType::Enum PixelFormat>
class TileIterator {
    public:
        // this is necessary to be able to implement lowerRight() in Tile
        friend class Tile<PixelFormat>;
        friend class ImageBufferIterator<PixelFormat>;


        typedef typename ValueTypeInfo<PixelFormat>::Type format;
        

        TileIterator (Tile<PixelFormat>* tile);

        TileIterator(const TileIterator<PixelFormat> &other);
        virtual ~TileIterator();


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


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

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

        TileIterator<PixelFormat>& operator++();

        TileIterator<PixelFormat>& operator--();

        TileIterator<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:
        unsigned int m_extent;
        unsigned int m_bands;
        format* m_startPos;
        format* m_currentPos;
    protected:

        TileIterator();
};

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>::TileIterator (Tile<PixelFormat>* tile) {
    m_extent = tile->m_extent;
    m_bands = tile->m_bands;
    m_startPos = tile->m_data;
    m_currentPos = tile->m_data;
}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>::TileIterator(const TileIterator<PixelFormat>& other) {
    m_extent = other.m_extent;
    m_bands = other.m_bands;
    m_startPos = other.m_startPos;
    m_currentPos = other.m_currentPos;
}


template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>::TileIterator () {
    m_extent = 0;
    m_bands = 0;
    m_startPos = 0;
    m_currentPos = 0;
}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>::~TileIterator () {}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>& TileIterator<PixelFormat>::operator=(const TileIterator<PixelFormat>& other) {
    if (this != &other) {
        m_extent = other.m_extent;
        m_bands = other.m_bands;
        m_startPos = other.m_startPos;
        m_currentPos = other.m_currentPos;
    }

    return *this;
}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>& TileIterator<PixelFormat>::operator++() {
    assert (m_currentPos + m_bands <= (m_startPos + (m_extent) * (m_extent) * m_bands));
    m_currentPos += m_bands;
    return *this;
}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>& TileIterator<PixelFormat>::operator--() {
    assert (m_currentPos >= m_startPos + m_bands);
    m_currentPos -= m_bands;
    return *this;
}

template <ValueType::Enum PixelFormat>
TileIterator<PixelFormat>& TileIterator<PixelFormat>::moveTo (unsigned int x, unsigned int y) {
    assert ((x <= m_extent) && (y <= m_extent));
    m_currentPos = m_startPos + m_bands * (m_extent * y + x);
    return *this;
}

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

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

template <ValueType::Enum PixelFormat>
typename TileIterator<PixelFormat>::format* TileIterator<PixelFormat>::operator() (unsigned int x, unsigned int y) {
    assert ((x < m_extent) && (y < m_extent));
    return m_startPos + m_bands * (m_extent * y + x);
}

template <ValueType::Enum PixelFormat>
const typename  TileIterator<PixelFormat>::format* TileIterator<PixelFormat>::operator() (unsigned int x, unsigned int y) const {
    assert ((x < m_extent) && (y < m_extent));
    return m_startPos + m_bands * (m_extent * y + x);
}

template <ValueType::Enum PixelFormat>
typename  TileIterator<PixelFormat>::format& TileIterator<PixelFormat>::operator[] (unsigned int n) {
    assert (n < m_bands);
    return *(m_currentPos + n);
}

template <ValueType::Enum PixelFormat>
const typename TileIterator<PixelFormat>::format TileIterator<PixelFormat>::operator[] (unsigned int n) const {
    assert (n < m_bands);
    return *(m_currentPos + n);
}

template <ValueType::Enum PixelFormat>
typename TileIterator<PixelFormat>::format TileIterator<PixelFormat>::getValue (unsigned int band) const {
    assert (band < m_bands);
    return *(m_currentPos + band);
}

template <ValueType::Enum PixelFormat>
void TileIterator<PixelFormat>::setValue (unsigned int band, typename TileIterator<PixelFormat>::format value) {
    assert (band < m_bands);
    *(m_currentPos + band) = value;
}

template <ValueType::Enum PixelFormat>
const unsigned int TileIterator<PixelFormat>::getX() const {
    ptrdiff_t tmp = m_currentPos - m_startPos;
    tmp /= m_bands;
    return tmp % m_extent;
}

template <ValueType::Enum PixelFormat>
const unsigned int TileIterator<PixelFormat>::getY() const {
    ptrdiff_t tmp = m_currentPos - m_startPos;
    tmp /= m_bands;
    return tmp / m_extent;
}

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

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


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

template <ValueType::Enum PixelFormat>
typename Tile<PixelFormat>::Iterator Tile<PixelFormat>::lowerRight() {
    TileIterator<PixelFormat> iterator(this);
    // move to the pixel after the last valid pixel
    iterator.moveTo(m_extent, m_extent - 1);
    return iterator;
}

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

}

#endif