TransformImage.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 TRANSFORMIMAGE_H
#define TRANSFORMIMAGE_H

#include "MipMap.hpp"
#include "ImageBuffer.hpp"
#include "UpdateInfo.hpp"

#include <vector>
#include <boost/thread.hpp>

namespace FotoSHOCKcore{

template <ValueType::Enum InPixelType, ValueType::Enum OutPixelType, typename Functor>
void transformImage_impl(ImageBuffer<InPixelType>& src, ImageBuffer<OutPixelType>& dest, Functor func,
                         const unsigned int srcNumOfTilesHoriz, const unsigned int destNumOfTilesHoriz,
                         const unsigned int srcNumOfTilesVert, const unsigned int destNumOfTilesVert,
                         const unsigned int srcTileExtent, ROIinfo &ROI, const long stamp);


template <ValueType::Enum InPixelType, ValueType::Enum OutPixelType, typename Functor>
void transformImage(MipMap* src, MipMap* dest, Functor func, std::vector<UpdateInfo>& ROIlist, const long stamp) {
    for (typename std::vector<UpdateInfo>::iterator ROI = ROIlist.begin(); ROI != ROIlist.end(); ++ROI) {
        const int level = ROI->ROI->mipmapLevel;

        const unsigned int srcNumOfTilesHoriz = (*src)[level]->getNumOfTilesHoriz();
        const unsigned int srcNumOfTilesVert = (*src)[level]->getNumOfTilesVert();

        const unsigned int destNumOfTilesHoriz = (*dest)[level]->getNumOfTilesHoriz();
        const unsigned int destNumOfTilesVert = (*dest)[level]->getNumOfTilesVert();
        const unsigned int destTileExtent = (*dest)[level]->getTileExtent();

        transformImage_impl(*static_cast<ImageBuffer<InPixelType>*>((*src)[level]), *static_cast<ImageBuffer<OutPixelType>*>((*dest)[level]),
                            func, srcNumOfTilesHoriz, destNumOfTilesHoriz, srcNumOfTilesVert,
                            destNumOfTilesVert, destTileExtent, *(ROI->ROI), stamp);
    }
}

template <ValueType::Enum PixelType, typename Functor>
void transformImage(MipMap* src, MipMap* dest, Functor func, std::vector<UpdateInfo>& ROIlist, const long stamp) {
    transformImage<PixelType, PixelType>(src, dest, func, ROIlist, stamp);
}

template <ValueType::Enum InPixelType, ValueType::Enum OutPixelType, typename Functor>
void transformImage(ImageBuffer<InPixelType>& src, ImageBuffer<OutPixelType>& dest, Functor func, std::vector<ROIinfo>& ROIlist, const long stamp) {
    if ((src.getWidth() != dest.getWidth()) || (src.getHeight() != dest.getHeight())) {
        // TODO: throw an exception
        return;
    }

    const unsigned int srcNumOfTilesHoriz = src.getNumOfTilesHoriz();
    const unsigned int srcNumOfTilesVert = src.getNumOfTilesVert();

    const unsigned int destNumOfTilesHoriz = dest.getNumOfTilesHoriz();
    const unsigned int destNumOfTilesVert = dest.getNumOfTilesVert();
    const unsigned int destTileExtent = dest.getTileExtent();

    for (typename std::vector<ROIinfo>::iterator ROI = ROIlist.begin(); ROI != ROIlist.end(); ++ROI) {
        transformImage_impl(src, dest, func, srcNumOfTilesHoriz, destNumOfTilesHoriz, srcNumOfTilesVert,
                            destNumOfTilesVert, destTileExtent, *ROI, stamp);
    }
}

template <ValueType::Enum InPixelType, ValueType::Enum OutPixelType, typename Functor>
void transformImage_impl(ImageBuffer<InPixelType>& src, ImageBuffer<OutPixelType>& dest, Functor func,
                         const unsigned int srcNumOfTilesHoriz, const unsigned int destNumOfTilesHoriz,
                         const unsigned int srcNumOfTilesVert, const unsigned int destNumOfTilesVert,
                         const unsigned int destTileExtent, ROIinfo &ROI, const long stamp)
{
    const unsigned int startTileVert = ROI.y / destTileExtent;
    unsigned int endTileVert = std::ceil((ROI.y + ROI.sizeY) / (double)destTileExtent);
    const unsigned int startTileHoriz = ROI.x / destTileExtent;
    unsigned int endTileHoriz = std::ceil((ROI.x + ROI.sizeX) / (double)destTileExtent);

    if ((srcNumOfTilesHoriz == destNumOfTilesHoriz) && (srcNumOfTilesVert == destNumOfTilesVert) &&
        (destTileExtent == src.getTileExtent()))
    {
        const unsigned int destTilePixels = destTileExtent * destTileExtent;

        for (unsigned int tileVert = startTileVert; tileVert < endTileVert; tileVert++) {
            for (unsigned int tileHoriz = startTileHoriz; tileHoriz < endTileHoriz; tileHoriz++) {
                Tile<OutPixelType>* destTile = dest.getTile(tileHoriz, tileVert);
                if (destTile->getStamp() != stamp) {
                    boost::this_thread::interruption_point();
                    typename Tile<InPixelType>::Iterator srcIt = src.getTile(tileHoriz, tileVert)->upperLeft();
                    typename Tile<OutPixelType>::Iterator destIt = destTile->upperLeft();

                    unsigned int pixel = destTilePixels;
                    do {
                        --pixel;
                        func(*srcIt, *destIt);

                        ++srcIt;
                        ++destIt;
                    } while (pixel != 0);
                    destTile->setStamp(stamp);
                }
            }
        }
    } else {
        // transformation when the number and the size of tiles are different
        unsigned int yoffset = 0;
        for (unsigned int tileVert = startTileVert; tileVert < endTileVert; tileVert++, yoffset += destTileExtent) {
            unsigned int xoffset = 0;
            for (unsigned int tileHoriz = startTileHoriz; tileHoriz < endTileHoriz; tileHoriz++, xoffset += destTileExtent) {
                Tile<OutPixelType>* destTile = dest.getTile(tileHoriz, tileVert);
                if (destTile->getStamp() != stamp) {
                    typename ImageBuffer<InPixelType>::Iterator srcIt = src.upperLeft();
                    typename Tile<OutPixelType>::Iterator destIt = destTile->upperLeft();

                    for (unsigned int y = 0; y < destTileExtent; ++y) {
                        srcIt.moveTo(xoffset, yoffset + y);
                        for (unsigned int x = 0; x < destTileExtent; ++x) {
                            func(*srcIt, *destIt);

                            ++srcIt;
                            ++destIt;
                        }
                    }

                    destTile->setStamp(stamp);
                }
            }
        }
    }
}

}

#endif