lsst.afw.math.detail Namespace Reference

Namespaces
	ConvolveGpuStatus
	gpu
	WarpImageGpuStatus

Classes
class	KernelImagesForRegion
class	RowOfKernelImagesForRegion
	A row of KernelImagesForRegion. More...
struct	ConvolveWithInterpolationWorkingImages
	kernel images used by convolveRegionWithInterpolation More...
class	PositionFunctor
	Base class to transform pixel position for a destination image to its position in the original source image. More...
class	WcsPositionFunctor
	Derived functor class to transform pixel position for a destination image to its position in the source image. The transform is from one WCS to another. More...
class	AffineTransformPositionFunctor
	Derived functor class to transform pixel position for a destination image to its position in the source image via an AffineTransform. More...
class	Spline
class	TautSpline
class	SmoothedSpline
struct	TrapezoidalPacker
class	WarpAtOnePoint
	A functor that computes one warped pixel. More...

Typedefs
typedef lsst::afw::image::VariancePixel	VarPixel
typedef lsst::afw::image::MaskPixel	MskPixel
typedef double	KerPixel

Enumerations
enum	SpatialFunctionType_t { sftChebyshev, sftPolynomial }

Functions
template<typename OutImageT , typename InImageT >
void	assertDimensionsOK (OutImageT const &convolvedImage, InImageT const &inImage, lsst::afw::math::Kernel const &kernel)
template<typename OutImageT , typename InImageT >
void	basicConvolve (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::Kernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
	Low-level convolution function that does not set edge pixels. More...
template<typename OutImageT , typename InImageT >
void	basicConvolve (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::DeltaFunctionKernel const &kernel, lsst::afw::math::ConvolutionControl const &)
	A version of basicConvolve that should be used when convolving delta function kernels. More...
template<typename OutImageT , typename InImageT >
void	basicConvolve (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::LinearCombinationKernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
	A version of basicConvolve that should be used when convolving a LinearCombinationKernel. More...
template<typename OutImageT , typename InImageT >
void	basicConvolve (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::SeparableKernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
	A version of basicConvolve that should be used when convolving separable kernels. More...
template<typename OutImageT , typename InImageT >
void	convolveWithBruteForce (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::Kernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
	Convolve an Image or MaskedImage with a Kernel by computing the kernel image at every point. (If the kernel is not spatially varying then only compute it once). More...
template<typename OutImageT , typename InImageT >
void	convolveWithInterpolation (OutImageT &outImage, InImageT const &inImage, lsst::afw::math::Kernel const &kernel, ConvolutionControl const &convolutionControl)
	Convolve an Image or MaskedImage with a spatially varying Kernel using linear interpolation. More...
template<typename OutImageT , typename InImageT >
void	convolveRegionWithInterpolation (OutImageT &outImage, InImageT const &inImage, KernelImagesForRegion const &region, ConvolveWithInterpolationWorkingImages &workingImages)
	Convolve a region of an Image or MaskedImage with a spatially varying Kernel using interpolation. More...
template<typename OutImageT , typename InImageT >
ConvolveGpuStatus::ReturnCode	basicConvolveGPU (OutImageT &convolvedImage, InImageT const &inImage, lsst::afw::math::Kernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
template<typename OutPixelT , typename InPixelT >
ConvolveGpuStatus::ReturnCode	convolveLinearCombinationGPU (lsst::afw::image::MaskedImage< OutPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > &convolvedImage, lsst::afw::image::MaskedImage< InPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > const &inImage, lsst::afw::math::LinearCombinationKernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
template<typename OutPixelT , typename InPixelT >
ConvolveGpuStatus::ReturnCode	convolveLinearCombinationGPU (lsst::afw::image::Image< OutPixelT > &convolvedImage, lsst::afw::image::Image< InPixelT > const &inImage, lsst::afw::math::LinearCombinationKernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
template<typename OutPixelT , typename InPixelT >
ConvolveGpuStatus::ReturnCode	convolveSpatiallyInvariantGPU (lsst::afw::image::MaskedImage< OutPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > &convolvedImage, lsst::afw::image::MaskedImage< InPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > const &inImage, lsst::afw::math::Kernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
template<typename OutPixelT , typename InPixelT >
ConvolveGpuStatus::ReturnCode	convolveSpatiallyInvariantGPU (lsst::afw::image::Image< OutPixelT > &convolvedImage, lsst::afw::image::Image< InPixelT > const &inImage, lsst::afw::math::Kernel const &kernel, lsst::afw::math::ConvolutionControl const &convolutionControl)
bool	IsSufficientSharedMemoryAvailable_ForImgBlock (int filterW, int filterH, int pixSize)
bool	IsSufficientSharedMemoryAvailable_ForImgAndMaskBlock (int filterW, int filterH, int pixSize)
bool	IsSufficientSharedMemoryAvailable_ForSfn (int order, int kernelN)
template<typename DestImageT , typename SrcImageT >
std::pair< int, WarpImageGpuStatus::ReturnCode >	warpImageGPU (DestImageT &destImage, SrcImageT const &srcImage, lsst::afw::math::LanczosWarpingKernel const &warpingKernel, lsst::afw::math::SeparableKernel const &maskWarpingKernel, PositionFunctor const &computeSrcPos, int const interpLength, typename DestImageT::SinglePixel padValue, const bool forceProcessing=true)
	GPU accelerated image warping using Lanczos resampling. More...
void	TestGpuKernel (int &ret1, int &ret2)

Typedef Documentation

typedef double lsst::afw::math::detail.KerPixel

Definition at line 46 of file convCUDA.h.

typedef lsst::afw::image::MaskPixel lsst::afw::math::detail.MskPixel

Definition at line 45 of file convCUDA.h.

typedef lsst::afw::image::VariancePixel lsst::afw::math::detail.VarPixel

Definition at line 44 of file convCUDA.h.

Enumeration Type Documentation

enum lsst::afw::math::detail::SpatialFunctionType_t

Enumerator
sftChebyshev
sftPolynomial

Definition at line 45 of file cudaConvWrapper.h.

{ sftChebyshev, sftPolynomial};

Function Documentation

template<typename OutImageT , typename InImageT >

void lsst::afw::math::detail::assertDimensionsOK	(	OutImageT const &	convolvedImage,
		InImageT const &	inImage,
		lsst::afw::math::Kernel const &	kernel
	)

Definition at line 59 of file convCpuGpuShared.cc.

  {
    if (convolvedImage.getDimensions() != inImage.getDimensions()) {
        std::ostringstream os;
        os << "convolvedImage dimensions = ( "
        << convolvedImage.getWidth() << ", " << convolvedImage.getHeight()
        << ") != (" << inImage.getWidth() << ", " << inImage.getHeight() << ") = inImage dimensions";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }
    if (inImage.getWidth() < kernel.getWidth() || inImage.getHeight() < kernel.getHeight()) {
        std::ostringstream os;
        os << "inImage dimensions = ( "
        << inImage.getWidth() << ", " << inImage.getHeight()
        << ") smaller than (" << kernel.getWidth() << ", " << kernel.getHeight()
        << ") = kernel dimensions in width and/or height";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }
    if ((kernel.getWidth() < 1) || (kernel.getHeight() < 1)) {
        std::ostringstream os;
        os << "kernel dimensions = ( "
        << kernel.getWidth() << ", " << kernel.getHeight()
        << ") smaller than (1, 1) in width and/or height";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }
}

template<typename OutImageT , typename InImageT >

ConvolveGpuStatus::ReturnCode lsst::afw::math::detail::basicConvolveGPU	(	OutImageT &	convolvedImage,
		InImageT const &	inImage,
		lsst::afw::math::Kernel const &	kernel,
		lsst::afw::math::ConvolutionControl const &	convolutionControl
	)

template<typename OutPixelT , typename InPixelT >

ConvolveGpuStatus::ReturnCode lsst::afw::math::detail::convolveLinearCombinationGPU	(	lsst::afw::image::MaskedImage< OutPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > &	convolvedImage,
		lsst::afw::image::MaskedImage< InPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > const &	inImage,
		lsst::afw::math::LinearCombinationKernel const &	kernel,
		lsst::afw::math::ConvolutionControl const &	convolutionControl
	)

Parameters

convolvedImage	convolved image
inImage	image to convolve

template<typename OutPixelT , typename InPixelT >

ConvolveGpuStatus::ReturnCode lsst::afw::math::detail::convolveLinearCombinationGPU	(	lsst::afw::image::Image< OutPixelT > &	convolvedImage,
		lsst::afw::image::Image< InPixelT > const &	inImage,
		lsst::afw::math::LinearCombinationKernel const &	kernel,
		lsst::afw::math::ConvolutionControl const &	convolutionControl
	)

Parameters

convolvedImage	convolved image
inImage	image to convolve

template<typename OutImageT , typename InImageT >

void lsst::afw::math::detail::convolveRegionWithInterpolation	(	OutImageT &	outImage,
		InImageT const &	inImage,
		KernelImagesForRegion const &	region,
		ConvolveWithInterpolationWorkingImages &	workingImages
	)

Convolve a region of an Image or MaskedImage with a spatially varying Kernel using interpolation.

This is a low-level convolution function that does not set edge pixels.

Warning

: this is a low-level routine that performs no bounds checking.

Parameters

outImage	convolved image = inImage convolved with kernel
inImage	input image
region	kernel image region over which to convolve
workingImages	working kernel images

Definition at line 132 of file ConvolveWithInterpolation.cc.

{
    typedef typename OutImageT::xy_locator OutLocator;
    typedef typename InImageT::const_xy_locator InConstLocator;
    typedef KernelImagesForRegion::Image KernelImage;
    typedef KernelImage::const_xy_locator KernelConstLocator;
    
    CONST_PTR(afwMath::Kernel) kernelPtr = region.getKernel();
    geom::Extent2I const kernelDimensions(kernelPtr->getDimensions());
    workingImages.leftImage <<= *region.getImage(KernelImagesForRegion::BOTTOM_LEFT);
    workingImages.rightImage <<= *region.getImage(KernelImagesForRegion::BOTTOM_RIGHT);
    workingImages.kernelImage <<= workingImages.leftImage;

    afwGeom::Box2I const goodBBox = region.getBBox();
    afwGeom::Box2I const fullBBox = kernelPtr->growBBox(goodBBox);
    
    // top and right images are computed one beyond bbox boundary,
    // so the distance between edge images is bbox width/height pixels
    double xfrac = 1.0 / static_cast<double>(goodBBox.getWidth());
    double yfrac = 1.0 / static_cast<double>(goodBBox.getHeight());
    afwMath::scaledPlus(workingImages.leftDeltaImage, 
         yfrac,  *region.getImage(KernelImagesForRegion::TOP_LEFT),
        -yfrac, workingImages.leftImage);
    afwMath::scaledPlus(workingImages.rightDeltaImage,
         yfrac, *region.getImage(KernelImagesForRegion::TOP_RIGHT),
        -yfrac, workingImages.rightImage);

    KernelConstLocator const kernelLocator = workingImages.kernelImage.xy_at(0, 0);
    
    // The loop is a bit odd for efficiency: the initial value of workingImages.kernelImage
    // and related kernel images are set when they are allocated,
    // so they are not computed in the loop until after the convolution; to save cpu cycles
    // they are not computed at all for the last iteration.
    InConstLocator inLocator = inImage.xy_at(fullBBox.getMinX(), fullBBox.getMinY());
    OutLocator outLocator = outImage.xy_at(goodBBox.getMinX(), goodBBox.getMinY());
    for (int j = 0; ; ) {
        afwMath::scaledPlus(
            workingImages.deltaImage, xfrac, workingImages.rightImage, -xfrac, workingImages.leftImage);
        for (int i = 0; ; ) {
            *outLocator = afwMath::convolveAtAPoint<OutImageT, InImageT>(
                inLocator, kernelLocator, kernelDimensions.getX(), kernelDimensions.getY());
            ++outLocator.x();
            ++inLocator.x();
            ++i;
            if (i >= goodBBox.getWidth()) {
                break;
            }
            workingImages.kernelImage += workingImages.deltaImage;
        }

        ++j;
        if (j >= goodBBox.getHeight()) {
            break;
        }
        workingImages.leftImage += workingImages.leftDeltaImage;
        workingImages.rightImage += workingImages.rightDeltaImage;
        workingImages.kernelImage <<= workingImages.leftImage;
        inLocator += lsst::afw::image::detail::difference_type(-goodBBox.getWidth(), 1);
        outLocator += lsst::afw::image::detail::difference_type(-goodBBox.getWidth(), 1);
    }
}

template<typename OutPixelT , typename InPixelT >

ConvolveGpuStatus::ReturnCode lsst::afw::math::detail::convolveSpatiallyInvariantGPU	(	lsst::afw::image::MaskedImage< OutPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > &	convolvedImage,
		lsst::afw::image::MaskedImage< InPixelT, lsst::afw::image::MaskPixel, lsst::afw::image::VariancePixel > const &	inImage,
		lsst::afw::math::Kernel const &	kernel,
		lsst::afw::math::ConvolutionControl const &	convolutionControl
	)

Parameters

convolvedImage	convolved image
inImage	image to convolve
kernel	convolution kernel

template<typename OutPixelT , typename InPixelT >

ConvolveGpuStatus::ReturnCode lsst::afw::math::detail::convolveSpatiallyInvariantGPU	(	lsst::afw::image::Image< OutPixelT > &	convolvedImage,
		lsst::afw::image::Image< InPixelT > const &	inImage,
		lsst::afw::math::Kernel const &	kernel,
		lsst::afw::math::ConvolutionControl const &	convolutionControl
	)

Parameters

convolvedImage	convolved image
inImage	image to convolve
kernel	convolution kernel

template<typename OutImageT , typename InImageT >

void lsst::afw::math::detail::convolveWithInterpolation	(	OutImageT &	outImage,
		InImageT const &	inImage,
		lsst::afw::math::Kernel const &	kernel,
		ConvolutionControl const &	convolutionControl
	)

Convolve an Image or MaskedImage with a spatially varying Kernel using linear interpolation.

This is a low-level convolution function that does not set edge pixels.

The algorithm is as follows:

• divide the image into regions whose size is no larger than maxInterpolationDistance
• for each region:
  • convolve it using convolveRegionWithInterpolation (which see)

Note that this routine will also work with spatially invariant kernels, but not efficiently.

Exceptions

lsst::pex::exceptions::InvalidParameterError

if outImage is not the same size as inImage

Parameters

outImage	convolved image = inImage convolved with kernel
inImage	input image
kernel	convolution kernel
convolutionControl	convolution control parameters

Definition at line 71 of file ConvolveWithInterpolation.cc.

{
    if (outImage.getDimensions() != inImage.getDimensions()) {
        std::ostringstream os;
        os << "outImage dimensions = ( "
            << outImage.getWidth() << ", " << outImage.getHeight()
            << ") != (" << inImage.getWidth() << ", " << inImage.getHeight() << ") = inImage dimensions";
        throw LSST_EXCEPT(pexExcept::InvalidParameterError, os.str());
    }

    // compute region covering good area of output image
    afwGeom::Box2I fullBBox = afwGeom::Box2I(
        afwGeom::Point2I(0, 0), 
        afwGeom::Extent2I(outImage.getWidth(), outImage.getHeight()));
    afwGeom::Box2I goodBBox = kernel.shrinkBBox(fullBBox);
    KernelImagesForRegion goodRegion(KernelImagesForRegion(
        kernel.clone(),
        goodBBox,
        inImage.getXY0(),
        convolutionControl.getDoNormalize()));
    pexLog::TTrace<6>("lsst.afw.math.convolve",
        "convolveWithInterpolation: full bbox minimum=(%d, %d), extent=(%d, %d)",
            fullBBox.getMinX(), fullBBox.getMinY(),
            fullBBox.getWidth(), fullBBox.getHeight());
    pexLog::TTrace<6>("lsst.afw.math.convolve",
        "convolveWithInterpolation: goodRegion bbox minimum=(%d, %d), extent=(%d, %d)",
            goodRegion.getBBox().getMinX(), goodRegion.getBBox().getMinY(),
            goodRegion.getBBox().getWidth(), goodRegion.getBBox().getHeight());

    // divide good region into subregions small enough to interpolate over
    int nx = 1 + (goodBBox.getWidth() / convolutionControl.getMaxInterpolationDistance());
    int ny = 1 + (goodBBox.getHeight() / convolutionControl.getMaxInterpolationDistance());
    pexLog::TTrace<4>("lsst.afw.math.convolve",
        "convolveWithInterpolation: divide into %d x %d subregions", nx, ny);

    ConvolveWithInterpolationWorkingImages workingImages(kernel.getDimensions());
    RowOfKernelImagesForRegion regionRow(nx, ny);
    while (goodRegion.computeNextRow(regionRow)) {
        for (RowOfKernelImagesForRegion::ConstIterator rgnIter = regionRow.begin(), rgnEnd = regionRow.end();
            rgnIter != rgnEnd; ++rgnIter) {
            pexLog::TTrace<6>("lsst.afw.math.convolve",
                "convolveWithInterpolation: bbox minimum=(%d, %d), extent=(%d, %d)",
                    (*rgnIter)->getBBox().getMinX(), (*rgnIter)->getBBox().getMinY(),
                    (*rgnIter)->getBBox().getWidth(), (*rgnIter)->getBBox().getHeight());
            convolveRegionWithInterpolation(outImage, inImage, **rgnIter, workingImages);
        }
    }
}

bool lsst::afw::math::detail::IsSufficientSharedMemoryAvailable_ForImgAndMaskBlock	(	int	filterW,
		int	filterH,
		int	pixSize
	)

Definition at line 55 of file cudaConvWrapper.cc.

{
    return false;
}

bool lsst::afw::math::detail::IsSufficientSharedMemoryAvailable_ForImgBlock	(	int	filterW,
		int	filterH,
		int	pixSize
	)

Definition at line 51 of file cudaConvWrapper.cc.

{
    return false;
}

bool lsst::afw::math::detail::IsSufficientSharedMemoryAvailable_ForSfn	(	int	order,
		int	kernelN
	)

Definition at line 59 of file cudaConvWrapper.cc.

{
    return false;
}

void lsst::afw::math::detail::TestGpuKernel	(	int &	ret1,
		int &	ret2
	)

Definition at line 46 of file cudaConvWrapper.cc.

                                         {
    ret1 = 0;
    ret2 = 0;
}

template<typename DestImageT , typename SrcImageT >

std::pair< int, WarpImageGpuStatus::ReturnCode > lsst::afw::math::detail::warpImageGPU	(	DestImageT &	destImage,
		SrcImageT const &	srcImage,
		lsst::afw::math::LanczosWarpingKernel const &	warpingKernel,
		lsst::afw::math::SeparableKernel const &	maskWarpingKernel,
		PositionFunctor const &	computeSrcPos,
		int const	interpLength,
		typename DestImageT::SinglePixel	padValue,
		const bool	forceProcessing = true
	)

GPU accelerated image warping using Lanczos resampling.

Returns

a std::pair<int,WarpImageGpuStatus::ReturnValue> containing: 1) the number of valid pixels in destImage (those that are not edge pixels). 2) whether the warping was performed successfully, or error code (if not OK, then the first value is not defined)

This function requires a Lanczos warping kernel to perform the source value estimation.

This function will not perform the warping if kernel size is too large. (currently, when the order of the Lanczos kernel is >50) If warping is not performed, the second elemnt of return value will not equal OK. If forceProcessing is true:

• this function will throw exceptions if a GPU device cannot be selected or used If forceProcessing is false:
• the warping will not be performed if the GPU code path is estimated to be slower than the CPU code path. That might happen if interpLength is too small (less than 3).
• the warping will not be performed if a GPU device cannot be selected or used

Precondition

maskWarpingKernel must not be greater in size than warpingKernel

Also see lsst::afw::math::warpImage()

Implementation: Calculates values of the coordinate transform function at some points, which are spaced by interpLength intervals. Calls CalculateInterpolationData() to calculate interpolation data from values of coordinate transformation fn. Calls WarpImageGpuWrapper() to perform the wapring.

Exceptions

lsst::pex::exceptions::InvalidParameterError	if interpLength < 1
lsst::pex::exceptions::InvalidParameterError	if maskWarpingKernel is neither Lanczos, bilinear nor nearest neighbor
lsst::pex::exceptions::MemoryError	when allocation of CPU memory fails
lsst::afw::gpu::GpuMemoryError	when allocation or transfer to/from GPU memory fails
lsst::afw::gpu::GpuRuntimeError	when GPU code run fails

Parameters

destImage	remapped image
srcImage	source image
warpingKernel	warping kernel
maskWarpingKernel	mask warping kernel (can be the same as warping kernel)
computeSrcPos	Functor to compute source position
interpLength	Distance over which WCS can be linearily interpolated must be >0
padValue	value to use for undefined pixels
forceProcessing	if true, this function will perform the warping even when it is slower then the CPU code path

Definition at line 395 of file cudaLanczosWrapper.cc.

{
    if (interpLength < 1) {
        throw LSST_EXCEPT(pexExcept::InvalidParameterError,
                          "GPU accelerated warping must use interpolation");
    }

    int const srcWidth = srcImage.getWidth();
    int const srcHeight = srcImage.getHeight();
    pexLog::TTrace<3>("lsst.afw.math.warp", "(GPU) source image width=%d; height=%d", srcWidth, srcHeight);

    if (!lsst::afw::gpu::isGpuBuild()) {
        throw LSST_EXCEPT(afwGpu::GpuRuntimeError, "Afw not compiled with GPU support");
    }

#ifdef GPU_BUILD
    gpu::KernelType maskKernelType;
    {
        if (dynamic_cast<afwMath::LanczosWarpingKernel const*>(&maskWarpingKernel)) {
            maskKernelType = gpu::KERNEL_TYPE_LANCZOS;
        } else if (dynamic_cast<afwMath::BilinearWarpingKernel const*>(&maskWarpingKernel)) {
            maskKernelType = gpu::KERNEL_TYPE_BILINEAR;
        } else if (dynamic_cast<afwMath::NearestWarpingKernel const*>(&maskWarpingKernel)) {
            maskKernelType = gpu::KERNEL_TYPE_NEAREST_NEIGHBOR;
        } else {
            throw LSST_EXCEPT(pexExcept::InvalidParameterError, "unknown type of mask warping kernel");
        }
    }
#endif

    if (gpuDetail::TryToSelectCudaDevice(!forceProcessing) == false) {
        return std::pair<int, WarpImageGpuStatus::ReturnCode>(-1, WarpImageGpuStatus::NO_GPU);
    }
        
    int const mainKernelSize = 2 * lanczosKernel.getOrder();
    //do not process if the kernel is too large for allocated GPU local memory
    if (mainKernelSize * 2 > gpu::SIZE_MAX_WARPING_KERNEL) {
        return std::pair<int, WarpImageGpuStatus::ReturnCode>(-1, WarpImageGpuStatus::KERNEL_TOO_LARGE);
    }

    //do not process if the interpolation data is too large to make any speed gains
    if (!forceProcessing && interpLength < 3) {
        return std::pair<int, WarpImageGpuStatus::ReturnCode>(-1, WarpImageGpuStatus::INTERP_LEN_TOO_SMALL);
    }

    int const destWidth = destImage.getWidth();
    int const destHeight = destImage.getHeight();
    pexLog::TTrace<3>("lsst.afw.math.warp", "(GPU) remap image width=%d; height=%d", destWidth, destHeight);

    int const maxCol = destWidth - 1;
    int const maxRow = destHeight - 1;

#ifdef GPU_BUILD
    // Compute borders; use to prevent applying kernel outside of srcImage
    afwGeom::Box2I srcGoodBBox = lanczosKernel.shrinkBBox(srcImage.getBBox(afwImage::LOCAL));
#endif

    int const interpBlkNX = InterpBlkN(destWidth , interpLength);
    int const interpBlkNY = InterpBlkN(destHeight, interpLength);
    //GPU kernel input, will contain: for each interpolation block, all interpolation parameters
    gpuDetail::GpuBuffer2D<gpu::BilinearInterp> srcPosInterp(interpBlkNX, interpBlkNY);

    // calculate values of coordinate transform function
    for (int rowBand = 0; rowBand < interpBlkNY; rowBand++) {
        int row = min(maxRow, (rowBand * interpLength - 1));
        for (int colBand = 0; colBand < interpBlkNX; colBand++) {
            int col = min(maxCol, (colBand * interpLength - 1));
            afwGeom::Point2D srcPos = computeSrcPos(col, row);
            SPoint2 sSrcPos(srcPos);
            sSrcPos = MovePoint(sSrcPos, SVec2(-srcImage.getX0(), -srcImage.getY0()));
            srcPosInterp.Pixel(colBand, rowBand).o =  sSrcPos;
        }
    }

    CalculateInterpolationData(/*in,out*/srcPosInterp, interpLength, destWidth, destHeight);

    int numGoodPixels = 0;

    pexLog::TTrace<3>("lsst.afw.math.warp", "using GPU acceleration, remapping masked image");

#ifdef GPU_BUILD
    int maskKernelSize;
    if (maskKernelType == gpu::KERNEL_TYPE_LANCZOS) {
        maskKernelSize = 2 * dynamic_cast<afwMath::LanczosWarpingKernel const*>(&maskWarpingKernel)->getOrder();
    } else {
        maskKernelSize = 2;
    }
    numGoodPixels = WarpImageGpuWrapper(destImage,
                                        srcImage,
                                        mainKernelSize,
                                        maskKernelType,
                                        maskKernelSize,
                                        srcGoodBBox,
                                        srcPosInterp, interpLength, padValue
                                       );
#endif
    return std::pair<int, WarpImageGpuStatus::ReturnCode>(numGoodPixels, WarpImageGpuStatus::OK);
}