ImageTransformsGPU.h

Go to the documentation of this file.

// -*- c-basic-offset: 4 -*-
#ifndef _VIGRA_EXT_IMAGETRANSFORMSGPU_H
#define _VIGRA_EXT_IMAGETRANSFORMSGPU_H
 
#include <fstream>
#include <iostream>
#include <iomanip>
 
#include <hugin_shared.h>
#include <vigra/basicimage.hxx>
#include <vigra_ext/ROIImage.h>
#include <vigra_ext/Interpolators.h>
#include <vigra/accessor.hxx>
#include <vigra_ext/FunctorAccessor.h>
 
#include <hugin_math/hugin_math.h>
#include <hugin_utils/utils.h>
#include <appbase/ProgressDisplay.h>
 
using vigra::NumericTraits;
 
namespace vigra_ext
{
 
IMPEX void SetGPUDebugMessages(const bool doPrint);
 
bool IMPEX transformImageGPUIntern(const std::string& coordXformGLSL,
                             const std::string& interpolatorGLSL,
                             const int interpolatorSize,
                             const std::string& photometricGLSL,
                             const std::vector<double>& invLut,
                             const std::vector<double>& destLut,
                             const vigra::Diff2D srcSize,
                             const void* const srcBuffer,
                             const int srcGLInternalFormat, const int srcGLTransferFormat, const int srcGLFormat, const int srcGLType,
                             const void* const srcAlphaBuffer,
                             const int srcAlphaGLType,
                             const vigra::Diff2D destUL,
                             const vigra::Diff2D destSize,
                             void* const destBuffer,
                             const int destGLInternalFormat, const int destGLTransferFormat, const int destGLFormat, const int destGLType,
                             void* const destAlphaBuffer,
                             const int destAlphaGLType,
                             const bool warparound);
 
// This is to avoid including GL headers in this file.
enum {
    // gltypes
    XGL_BYTE=0, XGL_UNSIGNED_BYTE, XGL_SHORT, XGL_UNSIGNED_SHORT, XGL_INT, XGL_UNSIGNED_INT, XGL_FLOAT,
    // Internalformats
    XGL_RGBA8, XGL_RGBA16, XGL_RGBA32F, XGL_LUMINANCE8_ALPHA8, XGL_LUMINANCE16_ALPHA16, XGL_LUMINANCE_ALPHA32F,
    XGL_RGB8,  XGL_RGB16,  XGL_RGB32F,  XGL_LUMINANCE8,        XGL_LUMINANCE16,         XGL_LUMINANCE32F,
    // formats
    XGL_LUMINANCE, XGL_RGB, XGL_LUMINANCE_ALPHA, XGL_RGBA
};
 
struct Error_GpuNumericTraits_not_specialized_for_this_case { };
 
template <class A>
struct GpuNumericTraits {
    typedef Error_GpuNumericTraits_not_specialized_for_this_case ImagePixelComponentType;
    enum {NumBands = 0};
    enum {ImageGLInternalFormat = 0};
    enum {ImageGLTransferFormat = 0};
    enum {ImageGLFormat = 0};
    enum {ImagePixelComponentGLType = 0};
};
 
#define DEFINE_GPUNUMERICTRAITS(IMAGECOMPONENT, GLFORMAT, GLFORMATRGB, GLTRANSFER, GLTRANSFERRGB, GLTYPE) \
template<> \
struct GpuNumericTraits<IMAGECOMPONENT> { \
    typedef IMAGECOMPONENT ImagePixelComponentType; \
    enum {NumBands = 1}; \
    enum {ImageGLInternalFormat = GLFORMAT}; \
    enum {ImageGLTransferFormat = GLTRANSFER}; \
    enum {ImageGLFormat = XGL_LUMINANCE}; \
    enum {ImagePixelComponentGLType = GLTYPE}; \
}; \
template<> \
struct GpuNumericTraits<vigra::RGBValue<IMAGECOMPONENT, 0, 1, 2> > { \
    typedef IMAGECOMPONENT ImagePixelComponentType; \
    enum {NumBands = 3}; \
    enum {ImageGLInternalFormat = GLFORMATRGB}; \
    enum {ImageGLTransferFormat = GLTRANSFERRGB}; \
    enum {ImageGLFormat = XGL_RGB}; \
    enum {ImagePixelComponentGLType = GLTYPE}; \
}; \
template<> \
struct GpuNumericTraits<vigra::TinyVector<IMAGECOMPONENT, 2> > { \
    typedef IMAGECOMPONENT ImagePixelComponentType; \
    enum {NumBands = 2}; \
    enum {ImageGLInternalFormat = GLFORMAT}; \
    enum {ImageGLTransferFormat = GLFORMAT}; \
    enum {ImageGLFormat = XGL_LUMINANCE_ALPHA}; \
    enum {ImagePixelComponentGLType = GLTYPE}; \
}; \
template<> \
struct GpuNumericTraits<vigra::TinyVector<IMAGECOMPONENT, 4> > { \
    typedef IMAGECOMPONENT ImagePixelComponentType; \
    enum {NumBands = 4}; \
    enum {ImageGLInternalFormat = GLFORMATRGB}; \
    enum {ImageGLTransferFormat = GLFORMATRGB}; \
    enum {ImageGLFormat = XGL_RGBA}; \
    enum {ImagePixelComponentGLType = GLTYPE}; \
};
 
DEFINE_GPUNUMERICTRAITS(vigra::Int8,   XGL_LUMINANCE8_ALPHA8,   XGL_RGBA8,   XGL_LUMINANCE8,   XGL_RGB8,   XGL_BYTE);
DEFINE_GPUNUMERICTRAITS(vigra::UInt8,  XGL_LUMINANCE8_ALPHA8,   XGL_RGBA8,   XGL_LUMINANCE8,   XGL_RGB8,   XGL_UNSIGNED_BYTE);
DEFINE_GPUNUMERICTRAITS(vigra::Int16,  XGL_LUMINANCE16_ALPHA16, XGL_RGBA16,  XGL_LUMINANCE16,  XGL_RGB16,  XGL_SHORT);
DEFINE_GPUNUMERICTRAITS(vigra::UInt16, XGL_LUMINANCE16_ALPHA16, XGL_RGBA16,  XGL_LUMINANCE16,  XGL_RGB16,  XGL_UNSIGNED_SHORT);
DEFINE_GPUNUMERICTRAITS(vigra::Int32,  XGL_LUMINANCE_ALPHA32F,  XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_INT);
DEFINE_GPUNUMERICTRAITS(vigra::UInt32, XGL_LUMINANCE_ALPHA32F,  XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_UNSIGNED_INT);
DEFINE_GPUNUMERICTRAITS(float,         XGL_LUMINANCE_ALPHA32F,  XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_FLOAT);
 
// FIXME ACM this is wrong, there is no GL_DOUBLE for transfering doubles.
DEFINE_GPUNUMERICTRAITS(double,        XGL_LUMINANCE_ALPHA32F,  XGL_RGBA32F, XGL_LUMINANCE32F, XGL_RGB32F, XGL_FLOAT);
 
 
template <class SrcImageIterator, class SrcAccessor,
          class DestImageIterator, class DestAccessor,
          class TRANSFORM,
          class PixelTransform,
          class AlphaImageIterator, class AlphaAccessor,
          class Interpolator>
void transformImageGPUIntern(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)
{
    typedef typename SrcAccessor::value_type SrcValueType;
    typedef typename DestAccessor::value_type DestValueType;
    typedef typename AlphaAccessor::value_type AlphaValueType;
 
    vigra::Diff2D srcSize = src.second - src.first;
    vigra::Diff2D destSize = dest.second - dest.first;
 
    vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>
                                 interpol (src, interp, warparound);
 
    // Emit coordinate transform and interpolator as GLSL shader program.
 
    std::ostringstream coordXformOss;
    coordXformOss << std::setprecision(20) << std::showpoint;
    transform.emitGLSL(coordXformOss);
 
    std::ostringstream interpolatorOss;
    interpolatorOss << std::setprecision(20) << std::showpoint;
    interpol.emitGLSL(interpolatorOss);
 
    std::ostringstream photometricOss;
    std::vector<double> invLut;
    std::vector<double> destLut;
    photometricOss << std::setprecision(20) << std::showpoint;
    pixelTransform.emitGLSL(photometricOss, invLut, destLut);
 
    // Do remapping.
    // Give the GPU pointers directly to the image data, bypassing the vigra iterators and accessors.
    // This is cheating. It will not work if the iterators describe subsets of the images or if
    // the accessors perform computation.
    transformImageGPUIntern(coordXformOss.str(),
                            interpolatorOss.str(),
                            interp.size,
                            photometricOss.str(),
                            invLut,
                            destLut,
                            srcSize,
                            src.first[0],
                            GpuNumericTraits<SrcValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<SrcValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<SrcValueType>::ImageGLFormat,
                            GpuNumericTraits<SrcValueType>::ImagePixelComponentGLType,
                            NULL, /* no alpha buffer */
                            XGL_BYTE,
                            destUL,
                            destSize,
                            dest.first[0],
                            GpuNumericTraits<DestValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<DestValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<DestValueType>::ImageGLFormat,
                            GpuNumericTraits<DestValueType>::ImagePixelComponentGLType,
                            alpha.first[0],
                            GpuNumericTraits<AlphaValueType>::ImagePixelComponentGLType,
                            warparound);
 
}
 
 
template <class SrcImageIterator, class SrcAccessor,
          class SrcAlphaIterator, class SrcAlphaAccessor,
          class DestImageIterator, class DestAccessor,
          class TRANSFORM,
          class PixelTransform,
          class AlphaImageIterator, class AlphaAccessor,
          class Interpolator>
void transformImageAlphaGPUIntern(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)
{
    typedef typename SrcAccessor::value_type SrcValueType;
    typedef typename SrcAlphaAccessor::value_type SrcAlphaType;
    typedef typename DestAccessor::value_type DestValueType;
    typedef typename AlphaAccessor::value_type DestAlphaType;
 
    vigra::Diff2D srcSize = src.second - src.first;
    vigra::Diff2D destSize = dest.second - dest.first;
 
    // Note that GPU interpolators are the same for source images with and without alpha channels.
    vigra_ext::ImageInterpolator<SrcImageIterator, SrcAccessor, Interpolator>
                                 interpol (src, interp, warparound);
 
    // Emit coordinate transform and interpolator as GLSL shader program.
 
    std::ostringstream coordXformOss;
    coordXformOss << std::setprecision(20) << std::showpoint;
    if(!transform.emitGLSL(coordXformOss))
    {
        std::cerr << "nona: Found unsupported transformation in stack." << std::endl
             << "      This geometric transformation is not supported by GPU." << std::endl
             << "      Remove -g switch and try with CPU transformation." << std::endl;
        exit(1);
    };
 
    std::ostringstream interpolatorOss;
    interpolatorOss << std::setprecision(20) << std::showpoint;
    interpol.emitGLSL(interpolatorOss);
 
    std::ostringstream photometricOss;
    std::vector<double> invLut;
    std::vector<double> destLut;
    photometricOss << std::setprecision(20) << std::showpoint;
    pixelTransform.emitGLSL(photometricOss, invLut, destLut);
 
/*
    // Experiment: measure speedup with TinyVector4 source images.
    typedef typename GpuNumericTraits<SrcValueType>::ImagePixelComponentType SrcImagePixelComponentType;
    typedef vigra::TinyVector<SrcImagePixelComponentType, 4> SrcVectorValueType;
    //class SrcVectorPixelType : public SrcVectorValueType {
    //public:
    //    SrcVectorPixelType() : SrcVectorValueType() { }
    //    SrcVectorPixelType(const SrcImagePixelComponentType & s) : SrcVectorValueType(s) { }
    //    SrcVectorPixelType(const vigra::RGBValue<SrcImagePixelComponentType> & s) : SrcVectorValueType(s.red(), s.green(), s.blue(), 0) { }
    //};
    //std::allocator<SrcVectorPixelType> al;
    //vigra::BasicImage<SrcVectorPixelType, std::allocator<SrcVectorPixelType> > srcVectorImage(srcSize, al);
    vigra::BasicImage<SrcVectorValueType> srcVectorImage(srcSize);
    //vigra::copyImage(src, destImage(srcVectorImage));
    vigra::copyImage(srcAlpha.first, srcAlpha.first + (src.second - src.first), srcAlpha.second, srcVectorImage.upperLeft(), vigra::VectorComponentAccessor<SrcVectorValueType>(3));
 
    transformImageGPUIntern(coordXformOss.str(),
                            interpolatorOss.str(),
                            interp.size,
                            srcSize,
                            srcVectorImage[0],
                            GpuNumericTraits<SrcVectorValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<SrcVectorValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<SrcVectorValueType>::ImageGLFormat,
                            GpuNumericTraits<SrcVectorValueType>::ImagePixelComponentGLType,
                            NULL,
                            XGL_BYTE,
                            destUL,
                            destSize,
                            dest.first[0],
                            GpuNumericTraits<DestValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<DestValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<DestValueType>::ImageGLFormat,
                            GpuNumericTraits<DestValueType>::ImagePixelComponentGLType,
                            alpha.first[0],
                            GpuNumericTraits<DestAlphaType>::ImagePixelComponentGLType,
                            warparound);
*/
    // Do remapping.
    // Give the GPU pointers directly to the image data, bypassing the vigra iterators and accessors.
    // This is cheating. It will not work if the iterators describe subsets of the images or if
    // the accessors perform computation.
#if 1
    transformImageGPUIntern(coordXformOss.str(),
                            interpolatorOss.str(),
                            interp.size,
                            photometricOss.str(),
                            invLut,
                            destLut,
                            srcSize,
                            src.first[0],
                            GpuNumericTraits<SrcValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<SrcValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<SrcValueType>::ImageGLFormat,
                            GpuNumericTraits<SrcValueType>::ImagePixelComponentGLType,
                            srcAlpha.first[0],
                            GpuNumericTraits<SrcAlphaType>::ImagePixelComponentGLType,
                            destUL,
                            destSize,
                            dest.first[0],
                            GpuNumericTraits<DestValueType>::ImageGLInternalFormat,
                            GpuNumericTraits<DestValueType>::ImageGLTransferFormat,
                            GpuNumericTraits<DestValueType>::ImageGLFormat,
                            GpuNumericTraits<DestValueType>::ImagePixelComponentGLType,
                            alpha.first[0],
                            GpuNumericTraits<DestAlphaType>::ImagePixelComponentGLType,
                            warparound);
#endif
 
#if 0
    //vigra::FRGBImage phonyDest(destSize);
    vigra::FVector4Image phonyDest(destSize);
    vigra::FImage phonyDestAlpha(destSize);
    vigra::FRGBImage phonySrc(srcSize);
    vigra::FImage phonySrcAlpha(srcSize);
 
    transformImageGPUIntern(oss.str(), srcSize, phonySrc[0], XGL_FLOAT, XGL_RGB,
                            phonySrcAlpha[0], XGL_FLOAT, XGL_RED,
                            destUL, destSize, phonyDest[0], XGL_FLOAT, XGL_RGBA,
                            phonyDestAlpha[0], XGL_FLOAT, XGL_RED,
                            warparound);
 
    // Test accuracy
    int xstart = destUL.x;
    int xend   = destUL.x + destSize.x;
    int ystart = destUL.y;
    int yend   = destUL.y + destSize.y;
 
    double samples = 0.0;
    double sumError = 0.0;
    double sumErrorSq = 0.0;
 
    // create dest y iterator
    //vigra::FRGBImage::traverser yd = phonyDest.upperLeft();
    vigra::FVector4Image::traverser yd = phonyDest.upperLeft();
    vigra::FImage::traverser ydm = phonyDestAlpha.upperLeft();
    DestImageIterator ydest(dest.first);
    AlphaImageIterator ydesta(alpha.first);
 
    int numMessages = 0;
 
    for(int y=ystart; y < yend; ++y, ++yd.y, ++ydm.y, ++ydest.y, ++ydesta.y)
    {
        // create x iterators
        //vigra::FRGBImage::traverser xd(yd);
        vigra::FVector4Image::traverser xd(yd);
        vigra::FImage::traverser xdm(ydm);
        DestImageIterator xdest(ydest);
        AlphaImageIterator xdesta(ydesta);
 
        for(int x=xstart; x < xend; ++x, ++xd.x, ++xdm.x, ++xdest.x, ++xdesta.x)
        {
            double sx,sy;
            bool result = transform.transformImgCoordPartial(sx,sy,x,y);
            float errorX = (*xd)[2] - static_cast<float>(sx);
            float errorY = (*xd)[1] - static_cast<float>(sy);
            double error = sqrt(errorX * errorX + errorY * errorY);
 
            if (error != 0.0 && numMessages < 150) {
                std::cout << std::setprecision(20) << "pos=[" << x << ", " << y << "] shouldBe=[" << sx << ", " << sy << " is=[" << (*xd)[2] << ", " << (*xd)[1] << "] error=" << error << std::endl;
                ++numMessages;
            }
 
            sumError += error;
            sumErrorSq += (error * error);
 
            samples += 1.0;
 
            dest.third.set(NumericTraits<DestValueType>::fromRealPromote(std::min(255.0, std::max(0.0, 255.0 * 10.0 * error))), xdest);
            alpha.second.set(255, xdesta);
        }
    }
 
    double avgError = sumError/samples;
 
    std::cout << "numSamples=" << samples << std::endl
              << "average error=" << avgError << std::endl
              << "stddev=" << (sumErrorSq/samples - avgError*avgError) << std::endl;
#endif
 
};
 
 
template <class SrcImageIterator, class SrcAccessor,
          class DestImageIterator, class DestAccessor,
          class AlphaImageIterator, class AlphaAccessor,
          class TRANSFORM,
          class PixelTransform>
void transformImageGPU(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)
{
    switch (interpol) {
    case INTERP_CUBIC:
        DEBUG_DEBUG("using cubic interpolator");
    transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_cubic(), warparound,
                                 progress);
        break;
    case INTERP_SPLINE_16:
        DEBUG_DEBUG("interpolator: spline16");
    transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline16(), warparound,
                                 progress);
        break;
    case INTERP_SPLINE_36:
        DEBUG_DEBUG("interpolator: spline36");
    transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline36(), warparound,
                                 progress);
        break;
    case INTERP_SPLINE_64:
        DEBUG_DEBUG("interpolator: spline64");
    transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_spline64(), warparound,
                                 progress);
        break;
    case INTERP_SINC_256:
        DEBUG_DEBUG("interpolator: sinc 256");
    transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_sinc<8>(), warparound,
                                 progress);
        break;
    case INTERP_BILINEAR:
        transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_bilin(), warparound,
                                 progress);
        break;
    case INTERP_NEAREST_NEIGHBOUR:
        transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_nearest(), warparound,
                                 progress);
        break;
    case INTERP_SINC_1024:
        transformImageGPUIntern(src, dest, alpha, transform, pixelTransform, destUL,
                                 vigra_ext::interp_sinc<32>(), warparound,
                                 progress);
        break;
    }
}
 
template <class SrcImageIterator, class SrcAccessor,
          class SrcAlphaIterator, class SrcAlphaAccessor,
          class DestImageIterator, class DestAccessor,
          class AlphaImageIterator, class AlphaAccessor,
          class TRANSFORM, class PixelTransform>
void transformImageAlphaGPU(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)
{
    switch (interpol) {
    case INTERP_CUBIC:
        DEBUG_DEBUG("using cubic interpolator");
        transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                                              vigra_ext::interp_cubic(), warparound,
                              progress);
        break;
    case INTERP_SPLINE_16:
        DEBUG_DEBUG("interpolator: spline16");
    transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline16(), warparound,
                                      progress);
        break;
    case INTERP_SPLINE_36:
        DEBUG_DEBUG("interpolator: spline36");
    transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline36(),  warparound,
                                      progress);
        break;
    case INTERP_SPLINE_64:
        DEBUG_DEBUG("interpolator: spline64");
    transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_spline64(),  warparound,
                                      progress);
        break;
    case INTERP_SINC_256:
        DEBUG_DEBUG("interpolator: sinc 256");
    transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_sinc<8>(), warparound,
                                      progress);
        break;
    case INTERP_BILINEAR:
        transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_bilin(), warparound,
                                      progress);
        break;
    case INTERP_NEAREST_NEIGHBOUR:
        transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_nearest(), warparound,
                                      progress);
        break;
    case INTERP_SINC_1024:
        transformImageAlphaGPUIntern(src,srcAlpha, dest, alpha, transform, pixelTransform, destUL,
                              vigra_ext::interp_sinc<32>(), warparound,
                                      progress);
        break;
    }
}
 
}; // namespace
 
#endif // _VIGRA_EXT_IMAGETRANSFORMSGPU_H