ImageTransforms.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _VIGRA_EXT_IMAGETRANSFORMS_H
#define _VIGRA_EXT_IMAGETRANSFORMS_H
 
#include <fstream>
 
#include <vigra/basicimage.hxx>
#include <vigra_ext/ROIImage.h>
#include <vigra_ext/Interpolators.h>
#include <vigra_ext/pyramid2.h>
 
#include <hugin_math/hugin_math.h>
#include <hugin_utils/utils.h>
#include <appbase/ProgressDisplay.h>
 
namespace vigra_ext
{
 
template <class T>
T zeroNegative(T p)
{
    if (p < 0) {
        return vigra::NumericTraits<T>::zero();
    } else {
        return p;
    }
}
 
template <class T>
vigra::RGBValue<T> zeroNegative(vigra::RGBValue<T> p)
{
    if (p.red() < 0) p.setRed(vigra::NumericTraits<T>::zero());
    if (p.green() < 0) p.setGreen(vigra::NumericTraits<T>::zero());
    if (p.blue() < 0) p.setBlue(vigra::NumericTraits<T>::zero());
    return p;
}
 
 
template <class SrcImageIterator, class SrcAccessor,
          class DestImageIterator, class DestAccessor,
          class TRANSFORM,
          class PixelTransform,
          class AlphaImageIterator, class AlphaAccessor,
          class Interpolator>
void transformImageIntern(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                          vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
                          std::pair<AlphaImageIterator, AlphaAccessor> alpha,
                          TRANSFORM & transform,
                          PixelTransform & pixelTransform,
                          vigra::Diff2D destUL,
                          Interpolator interp,
                          bool warparound,
                          AppBase::ProgressDisplay* progress,
                          bool singleThreaded)
{
    const vigra::Diff2D destSize = dest.second - dest.first;
 
    const int xstart = destUL.x;
    const int xend = destUL.x + destSize.x;
    const int ystart = destUL.y;
    const int yend = destUL.y + destSize.y;
 
    vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>
        interpol(src, interp, warparound);
 
    // loop over the image and transform
#pragma omp parallel for if(!singleThreaded) schedule(dynamic) 
    for (int y = ystart; y < yend; ++y)
    {
        // create x iterators
        DestImageIterator xd(dest.first);
        xd.y += y - ystart;
        AlphaImageIterator xdm(alpha.first);
        xdm.y += y - ystart;
        typename SrcAccessor::value_type tempval;
        for (int x = xstart; x < xend; ++x, ++xd.x, ++xdm.x)
        {
            double sx, sy;
            if (transform.transformImgCoord(sx, sy, x, y)) {
                if (interpol.operator()(sx, sy, tempval)){
                    // apply pixel transform and write to output
                    dest.third.set(zeroNegative(pixelTransform(tempval, hugin_utils::FDiff2D(sx, sy))), xd);
                    alpha.second.set(pixelTransform.hdrWeight(tempval, vigra::UInt8(255)), xdm);
                }
                else {
                    alpha.second.set(0, xdm);
                }
            }
            else {
                alpha.second.set(0, xdm);
            }
        }
    }
}
 
template <class SrcImageIterator, class SrcAccessor,
          class SrcAlphaIterator, class SrcAlphaAccessor,
          class DestImageIterator, class DestAccessor,
          class TRANSFORM,
          class PixelTransform,
          class AlphaImageIterator, class AlphaAccessor,
          class Interpolator>
void transformImageAlphaIntern(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                               std::pair<SrcAlphaIterator, SrcAlphaAccessor> srcAlpha,
                               vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
                               std::pair<AlphaImageIterator, AlphaAccessor> alpha,
                               TRANSFORM & transform,
                               PixelTransform & pixelTransform,
                               vigra::Diff2D destUL,
                               Interpolator interp,
                               bool warparound,
                               AppBase::ProgressDisplay* progress,
                               bool singleThreaded)
{
    const vigra::Diff2D destSize = dest.second - dest.first;
 
    const int xstart = destUL.x;
    const int xend   = destUL.x + destSize.x;
    const int ystart = destUL.y;
    const int yend   = destUL.y + destSize.y;
 
    vigra_ext::ImageMaskInterpolator<SrcImageIterator, SrcAccessor, SrcAlphaIterator,
                                     SrcAlphaAccessor, Interpolator>
                                    interpol (src, srcAlpha, interp, warparound);
 
    // loop over the image and transform
#pragma omp parallel for if(!singleThreaded) schedule(dynamic)
    for(int y=ystart; y < yend; ++y)
    {
        // create x iterators
        DestImageIterator xd(dest.first);
        xd.y += y - ystart;
        AlphaImageIterator xdist(alpha.first);
        xdist.y += y - ystart;
        typename SrcAccessor::value_type tempval;
        typename SrcAlphaAccessor::value_type alphaval;
        for (int x = xstart; x < xend; ++x, ++xd.x, ++xdist.x)
        {
            double sx,sy;
            if (transform.transformImgCoord(sx,sy,x,y)) {
                // try to interpolate.
                if (interpol(sx, sy, tempval, alphaval)) {
                    dest.third.set(zeroNegative(pixelTransform(tempval, hugin_utils::FDiff2D(sx, sy))), xd);
                    alpha.second.set(pixelTransform.hdrWeight(tempval, alphaval), xdist);
                } else {
                    // point outside of image or mask
                    alpha.second.set(0, xdist);
                }
            } else {
                alpha.second.set(0, xdist);
            }
        }
    }
};
 
template <class SrcImageIterator, class SrcAccessor,
    class DestImageIterator, class DestAccessor,
    class TRANSFORM,
    class PixelTransform,
    class AlphaImageIterator, class AlphaAccessor,
    class Interpolator>
void transformImageInternAA(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
    vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
    std::pair<AlphaImageIterator, AlphaAccessor> alpha,
    TRANSFORM& transform,
    PixelTransform& pixelTransform,
    vigra::Diff2D destUL,
    Interpolator interp,
    bool warparound,
    AppBase::ProgressDisplay* progress,
    bool singleThreaded)
{
    const vigra::Diff2D destSize = dest.second - dest.first;
 
    const int xstart = destUL.x;
    const int xend = destUL.x + destSize.x;
    const int ystart = destUL.y;
    const int yend = destUL.y + destSize.y;
 
    typedef typename vigra::NumericTraits<typename SrcImageIterator::value_type>::RealPromote RealAccessor;
    // calculate max level for aa filtering depending on interpolator size
    const size_t maxLevel = std::floor(std::log2(std::min(destSize.x, destSize.y) / (2 * Interpolator::size)));
    std::cout << "MaxLevels=" << maxLevel << std::endl;
    // pyramids stores lower level of source image
    std::vector<vigra::BasicImage<typename SrcImageIterator::value_type>> pyramids(maxLevel);
    std::vector<hugin_utils::FDiff2D> scales;
    size_t w = (src.second - src.first).x;
    size_t h = (src.second - src.first).y;
    const size_t w0 = w;
    const size_t h0 = h;
    // now generate interpolator for level 0
    std::vector<vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>> interpolators;
    interpolators.push_back(vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>(src, interp, warparound));
    scales.push_back(hugin_utils::FDiff2D(1.0, 1.0));
    // build pyramids and corresponding ImageInterpolators for all levels
    if (maxLevel > 0)
    {
        for (size_t i = 0; i < maxLevel; ++i)
        {
            w = (w + 1) >> 1;
            h = (h + 1) >> 1;
            pyramids[i].resize(w, h);
            if (i == 0)
            {
                enblend::reduce<RealAccessor>(warparound, src.first, src.second, src.third,
                    pyramids[i].upperLeft(), pyramids[i].lowerRight(), pyramids[i].accessor());
            }
            else
            {
                enblend::reduce<RealAccessor>(warparound, pyramids[i - 1].upperLeft(), pyramids[i - 1].lowerRight(), pyramids[i - 1].accessor(),
                    pyramids[i].upperLeft(), pyramids[i].lowerRight(), pyramids[i].accessor());
            };
            interpolators.push_back(
                vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>(pyramids[i].upperLeft(), pyramids[i].lowerRight(), src.third, interp, warparound)
            );
            scales.push_back(hugin_utils::FDiff2D((double)w / w0, (double)h / h0));
        };
    };
 
    // loop over the image and transform
#pragma omp parallel for if(!singleThreaded) schedule(dynamic) 
    for (int y = ystart; y < yend; ++y)
    {
        // create x iterators
        DestImageIterator xd(dest.first);
        xd.y += y - ystart;
        AlphaImageIterator xdm(alpha.first);
        xdm.y += y - ystart;
        typename SrcAccessor::value_type tempval;
        // store last sucessful calculated position to speed up
        // calculation of scale level for aa interpolator
        bool last_valid = false;
        double last_sx, last_sy;
        for (int x = xstart; x < xend; ++x, ++xd.x, ++xdm.x)
        {
            double sx, sy;
            if (transform.transformImgCoord(sx, sy, x, y))
            {
                double scale = 1.0;
                // last position not valid, calculate new
                if (!last_valid)
                {
                    last_valid = transform.transformImgCoord(last_sx, last_sy, x, x + 1);
                };
                // calculate scale in x direction
                if (last_valid)
                {
                    // calculate scale and make sure it is >=1
                    scale = std::max(std::sqrt((last_sx - sx) * (last_sx - sx) + (last_sy - sy) * (last_sy - sy)), 1.0);
                };
                // now calculate scale in y direction
                double sxy, syy;
                if (transform.transformImgCoord(sxy, syy, x, y - 1))
                {
                    scale = std::max(std::sqrt((sxy - sx) * (sxy - sx) + (syy - sy) * (syy - sy)), scale);
                }
                else
                {
                    if (transform.transformImgCoord(sxy, syy, x, y + 1))
                    {
                        scale = std::max(std::sqrt((sxy - sx) * (sxy - sx) + (syy - sy) * (syy - sy)), scale);
                    };
                };
                const double fullLevel = std::max<double>(std::min<double>(std::log2(scale) - 1, maxLevel), 0.0);
                const int level = std::floor(fullLevel);
                if (x == xstart && y == ystart)
                {
                    std::cout << "Using level " << level << std::endl;
                };
                double sxl, syl;
                if (level > 0)
                {
                    sxl = (sx + 0.5) * scales[level].x - 0.5;
                    syl = (sy + 0.5) * scales[level].y - 0.5;
 
                }
                else
                {
                    sxl = sx;
                    syl = sy;
                };
                if (interpolators[level].operator()(sxl, syl, tempval))
                {
                    const double fraction = fullLevel - level;
                    if (fraction > 0.2)
                    {
                        typename SrcAccessor::value_type tempval2;
                        if (interpolators[level + 1]((sx + 0.5)* scales[level + 1].x - 0.5, (sy + 0.5)* scales[level + 1].y - 0.5, tempval2))
                        {
                            tempval = (1.0 - fraction) * tempval + fraction * tempval2;
                        };
                    };
                    // apply pixel transform and write to output
                    dest.third.set(zeroNegative(pixelTransform(tempval, hugin_utils::FDiff2D(sx, sy))), xd);
                    alpha.second.set(pixelTransform.hdrWeight(tempval, vigra::UInt8(255)), xdm);
                }
                else
                {
                    alpha.second.set(0, xdm);
                };
                last_valid = true;
                last_sx = sx;
                last_sy = sy;
            }
            else
            {
                alpha.second.set(0, xdm);
                last_valid = false;
            };
        };
    };
};
 
template <class SrcImageIterator, class SrcAccessor,
    class SrcAlphaIterator, class SrcAlphaAccessor,
    class DestImageIterator, class DestAccessor,
    class TRANSFORM,
    class PixelTransform,
    class AlphaImageIterator, class AlphaAccessor,
    class Interpolator>
void transformImageAlphaInternAA(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
    std::pair<SrcAlphaIterator, SrcAlphaAccessor> srcAlpha,
    vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
    std::pair<AlphaImageIterator, AlphaAccessor> alpha,
    TRANSFORM& transform,
    PixelTransform& pixelTransform,
    vigra::Diff2D destUL,
    Interpolator interp,
    bool warparound,
    AppBase::ProgressDisplay* progress,
    bool singleThreaded)
{
    const vigra::Diff2D destSize = dest.second - dest.first;
 
    const int xstart = destUL.x;
    const int xend = destUL.x + destSize.x;
    const int ystart = destUL.y;
    const int yend = destUL.y + destSize.y;
 
    typedef typename vigra::NumericTraits<typename SrcImageIterator::value_type>::RealPromote RealAccessor;
    typedef typename vigra::NumericTraits<typename SrcAlphaIterator::value_type>::Promote RealAlphaAccessor;
    // calculate max level for aa filtering depending on interpolator size
    const size_t maxLevel = std::floor(std::log2(std::min(destSize.x, destSize.y) / (2 * Interpolator::size)));
    std::cout << "MaxLevels=" << maxLevel << std::endl;
    // pyramids stores lower level of source image
    typedef vigra::BasicImage<typename SrcImageIterator::value_type> PyramidImageType;
    std::vector<PyramidImageType> pyramids(maxLevel);
    std::vector<vigra::BasicImage<typename SrcAlphaIterator::value_type>> pyramidsMasks(maxLevel);
    std::vector<hugin_utils::FDiff2D> scales;
    size_t w = (src.second - src.first).x;
    size_t h = (src.second - src.first).y;
    const size_t w0 = w;
    const size_t h0 = h;
    std::cout << "(Alpha) Initial size " << w << "x" << h << ", max level=" << maxLevel << std::endl;
    // now generate interpolator for level 0
    std::vector<vigra_ext::ImageMaskInterpolator<SrcImageIterator, SrcAccessor, SrcAlphaIterator, SrcAlphaAccessor, Interpolator>> interpolators;
    interpolators.push_back(vigra_ext::ImageMaskInterpolator<SrcImageIterator, SrcAccessor, SrcAlphaIterator, SrcAlphaAccessor, Interpolator>(src, srcAlpha, interp, warparound));
    scales.push_back(hugin_utils::FDiff2D(1.0, 1.0));
    // build pyramids and corresponding ImageInterpolators for all levels
    if (maxLevel > 0)
    {
        for (size_t i = 0; i < maxLevel; ++i)
        {
            w = (w + 1) >> 1;
            h = (h + 1) >> 1;
            pyramids[i].resize(w, h);
            pyramidsMasks[i].resize(w, h);
            if (i == 0)
            {
                enblend::reduce<RealAccessor, RealAlphaAccessor>(warparound, src.first, src.second, src.third,
                    srcAlpha.first, srcAlpha.second,
                    pyramids[i].upperLeft(), pyramids[i].lowerRight(), pyramids[i].accessor(),
                    pyramidsMasks[i].upperLeft(), pyramidsMasks[i].lowerRight(), pyramidsMasks[i].accessor());
            }
            else
            {
                enblend::reduce<RealAccessor, RealAlphaAccessor>(warparound, pyramids[i - 1].upperLeft(), pyramids[i - 1].lowerRight(), pyramids[i - 1].accessor(),
                    pyramidsMasks[i - 1].upperLeft(), pyramidsMasks[i - 1].accessor(),
                    pyramids[i].upperLeft(), pyramids[i].lowerRight(), pyramids[i].accessor(),
                    pyramidsMasks[i].upperLeft(), pyramidsMasks[i].lowerRight(), pyramidsMasks[i].accessor());
            };
            interpolators.push_back(
                vigra_ext::ImageMaskInterpolator<SrcImageIterator, SrcAccessor, SrcAlphaIterator, SrcAlphaAccessor, Interpolator>(
                    pyramids[i].upperLeft(), pyramids[i].lowerRight(), src.third,
                    pyramidsMasks[i].upperLeft(), srcAlpha.second,
                    interp, warparound)
            );
            scales.push_back(hugin_utils::FDiff2D((double)w / w0, (double)h / h0));
        };
    };
 
    // loop over the image and transform
#pragma omp parallel for if(!singleThreaded) schedule(dynamic)
    for (int y = ystart; y < yend; ++y)
    {
        // create x iterators
        DestImageIterator xd(dest.first);
        xd.y += y - ystart;
        AlphaImageIterator xdist(alpha.first);
        xdist.y += y - ystart;
        typename SrcAccessor::value_type tempval;
        typename SrcAlphaAccessor::value_type alphaval;
        // store last sucessful calculated position to speed up
        // calculation of scale level for aa interpolator
        bool last_valid = false;
        double last_sx, last_sy;
        for (int x = xstart; x < xend; ++x, ++xd.x, ++xdist.x)
        {
            double sx, sy;
            if (transform.transformImgCoord(sx, sy, x, y))
            {
                double scale = 1.0;
                // last position not valid, calculate new
                if (!last_valid)
                {
                    last_valid = transform.transformImgCoord(last_sx, last_sy, x, x + 1);
                };
                // calculate scale in x direction
                if (last_valid)
                {
                    // calculate scale and make sure it is >=1
                    scale = std::max(std::sqrt((last_sx - sx) * (last_sx - sx) + (last_sy - sy) * (last_sy - sy)), 1.0);
                };
                // now calculate scale in y direction
                double sxy, syy;
                if (transform.transformImgCoord(sxy, syy, x, y - 1))
                {
                    scale = std::max(std::sqrt((sxy - sx) * (sxy - sx) + (syy - sy) * (syy - sy)), scale);
                }
                else
                {
                    if (transform.transformImgCoord(sxy, syy, x, y + 1))
                    {
                        scale = std::max(std::sqrt((sxy - sx) * (sxy - sx) + (syy - sy) * (syy - sy)), scale);
                    };
                };
                const double fullLevel = std::max<double>(std::min<double>(std::log2(scale) - 1, maxLevel), 0.0);
                const int level = std::floor(fullLevel);
                if (x == xstart && y == ystart)
                {
                    std::cout << "Using level " << level << std::endl;
                };
                double sxl, syl;
                if (level > 0)
                {
                    sxl = (sx + 0.5) * scales[level].x - 0.5;
                    syl = (sy + 0.5) * scales[level].y - 0.5;
                }
                else
                {
                    sxl = sx;
                    syl = sy;
                };
                // try to interpolate.
                if (interpolators[level](sxl, syl, tempval, alphaval))
                {
                    const double fraction = fullLevel - level;
                    if (fraction > 0.2)
                    {
                        typename SrcAccessor::value_type tempval2;
                        typename SrcAlphaAccessor::value_type alphaval2;
                        if (interpolators[level + 1]((sx + 0.5)* scales[level + 1].x - 0.5, (sy + 0.5)* scales[level + 1].y - 0.5, tempval2, alphaval2))
                        {
                            tempval = (1.0 - fraction) * tempval + fraction * tempval2;
                            alphaval = (1.0 - fraction) * alphaval + fraction * alphaval2;
                        };
                    };
                    dest.third.set(zeroNegative(pixelTransform(tempval, hugin_utils::FDiff2D(sx, sy))), xd);
                    alpha.second.set(pixelTransform.hdrWeight(tempval, alphaval), xdist);
                }
                else
                {
                    // point outside of image or mask
                    alpha.second.set(0, xdist);
                };
                last_valid = true;
                last_sx = sx;
                last_sy = sy;
            }
            else
            {
                alpha.second.set(0, xdist);
                last_valid = false;
            };
        };
    };
}
 
template <class SrcImageIterator, class SrcAccessor,
          class DestImageIterator, class DestAccessor,
          class AlphaImageIterator, class AlphaAccessor,
          class TRANSFORM,
          class PixelTransform>
void transformImage(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                    vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
                    std::pair<AlphaImageIterator, AlphaAccessor> alpha,
                    vigra::Diff2D destUL,
                    TRANSFORM & transform,
                    PixelTransform & pixelTransform,
                    bool warparound,
                    Interpolator interpol,
                    AppBase::ProgressDisplay* progress, bool singleThreaded = false)
{
    switch (interpol) {
    case INTERP_CUBIC:
        DEBUG_DEBUG("using cubic interpolator");
    transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_cubic(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_SPLINE_16:
        DEBUG_DEBUG("interpolator: spline16");
    transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline16(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_SPLINE_36:
        DEBUG_DEBUG("interpolator: spline36");
    transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline36(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_SPLINE_64:
        DEBUG_DEBUG("interpolator: spline64");
    transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline64(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_SINC_256:
        DEBUG_DEBUG("interpolator: sinc 256");
    transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_sinc<8>(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_BILINEAR:
        transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_bilin(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_NEAREST_NEIGHBOUR:
        transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_nearest(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_SINC_1024:
        transformImageIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_sinc<32>(), warparound,
                                 progress, singleThreaded);
        break;
    case INTERP_AABOX:
        std::cout << "TransformImage AA, nearest" << std::endl;
        vigra_ext::transformImageInternAA(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_nearest(), warparound,
                                 progress, singleThreaded);
    break;
    case INTERP_AATRIANGLE:
        std::cout << "TransformImage AA, bilinear" << std::endl;
        vigra_ext::transformImageInternAA(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_bilin(), warparound,
                                 progress, singleThreaded);
    break;
    case INTERP_AACUBIC:
        std::cout << "TransformImage AA, cubic" << std::endl;
        vigra_ext::transformImageInternAA(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_cubic(), warparound,
                                 progress, singleThreaded);
    break;
    case INTERP_AALANCZOS:
        std::cout << "TransformImage AA, Lanzcos" << std::endl;
        vigra_ext::transformImageInternAA(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_sinc<8>(), warparound,
                                 progress, singleThreaded);
    break;
    }
}
 
template <class SrcImageIterator, class SrcAccessor,
          class SrcAlphaIterator, class SrcAlphaAccessor,
          class DestImageIterator, class DestAccessor,
          class AlphaImageIterator, class AlphaAccessor,
          class TRANSFORM, class PixelTransform>
void transformImageAlpha(vigra::triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
                         std::pair<SrcAlphaIterator, SrcAlphaAccessor> srcAlpha,
                         vigra::triple<DestImageIterator, DestImageIterator, DestAccessor> dest,
                         std::pair<AlphaImageIterator, AlphaAccessor> alpha,
                         vigra::Diff2D destUL,
                         TRANSFORM & transform,
                         PixelTransform & pixelTransform,
                         bool warparound,
                         Interpolator interpol,
                         AppBase::ProgressDisplay* progress, bool singleThreaded = false)
{
    switch (interpol) {
    case INTERP_CUBIC:
        DEBUG_DEBUG("using cubic interpolator");
        transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                                              vigra_ext::interp_cubic(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_SPLINE_16:
        DEBUG_DEBUG("interpolator: spline16");
    transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline16(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_SPLINE_36:
        DEBUG_DEBUG("interpolator: spline36");
    transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline36(),  warparound,
                              progress, singleThreaded);
        break;
    case INTERP_SPLINE_64:
        DEBUG_DEBUG("interpolator: spline64");
    transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline64(),  warparound,
                              progress, singleThreaded);
        break;
    case INTERP_SINC_256:
        DEBUG_DEBUG("interpolator: sinc 256");
    transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_sinc<8>(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_BILINEAR:
        transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_bilin(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_NEAREST_NEIGHBOUR:
        transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_nearest(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_SINC_1024:
        transformImageAlphaIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_sinc<32>(), warparound,
                              progress, singleThreaded);
        break;
    case INTERP_AABOX:
        std::cout << "TransformImage alpha AA, nearest" << std::endl;
        vigra_ext::transformImageAlphaInternAA(src, srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_nearest(), warparound,
                              progress, singleThreaded);
    break;
    case INTERP_AATRIANGLE:
        std::cout << "TransformImage alpha AA, linear" << std::endl;
        vigra_ext::transformImageAlphaInternAA(src, srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_bilin(), warparound,
                              progress, singleThreaded);
    break;
    case INTERP_AACUBIC:
        std::cout << "TransformImage alpha AA, cubic" << std::endl;
        vigra_ext::transformImageAlphaInternAA(src, srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_cubic(), warparound,
                              progress, singleThreaded);
    break;
    case INTERP_AALANCZOS:
        std::cout << "TransformImage alpha AA, Lanzcos" << std::endl;
        vigra_ext::transformImageAlphaInternAA(src, srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_sinc<8>(), warparound,
                              progress, singleThreaded);
    break;
    }
}
 
}; // namespace
 
#endif // _VIGRA_EXT_IMAGETRANSFORMS_H