cuda_gpu_geo_transformer.h

Go to the documentation of this file.

/***************************************************************************
 *
 * Authors:    David Strelak (davidstrelak@gmail.com)
 *
 * Unidad de  Bioinformatica of Centro Nacional de Biotecnologia , CSIC
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 * 02111-1307  USA
 *
 *  All comments concerning this program package may be sent to the
 *  e-mail address 'xmipp@cnb.csic.es'
 ***************************************************************************/

#ifndef CUDA_GEO_TRANSFORMER
#define CUDA_GEO_TRANSFORMER

#include <assert.h>
#include <stdexcept>
#include <memory>
#include "core/multidim_array.h"
#include "core/transformations.h"
#include "core/xmipp_image.h" // for tests only
#include "core/bilib/iirconvolve.h" // for tests only
#include "reconstruction/gpu_geo_transformer_defines.h"
#include "cuda_xmipp_utils.h"
#include "reconstruction_cuda/gpu.h"

template<typename T>
class GeoTransformer {

public:
    GeoTransformer() { setDefaultValues(); };

    ~GeoTransformer() {
        release();
    }

    void initForMatrix(size_t x, size_t y, size_t z);

    void initLazyForMatrix(size_t x, size_t y = 1, size_t z = 1);

    void initForBSpline(size_t inX, size_t inY, size_t inN,
            size_t splineX, size_t splineY, size_t splineN, const GPU &gpu);

    void initLazyForBSpline(size_t inX, size_t inY, size_t inN,
            size_t splineX, size_t splineY, size_t splineN, const GPU &gpu);

    void release();

    template<typename T_MAT>
    void applyGeometry(int splineDegree, MultidimArray<T> &output,
            const MultidimArray<T> &input, const Matrix2D<T_MAT> &transform,
            bool isInv, bool wrap, T outside = 0,
            const MultidimArray<T> *bCoeffsPtr = NULL);

    void applyBSplineTransform(int splineDegree,
        MultidimArray<T> &output, const MultidimArray<T> &input,
        const std::pair<Matrix1D<T>, Matrix1D<T>> &coeffs, size_t imageIdx, T outside = 0);

    void test();

private:
    template<typename T_MAT>
    void checkRestrictions(int splineDegree, MultidimArray<T> &output,
            const MultidimArray<T> &input, const Matrix2D<T_MAT> &transform);

    void checkRestrictions(int splineDegree,
            MultidimArray<T> &output, const MultidimArray<T> &input,
            const std::pair<Matrix1D<T>, Matrix1D<T>> &coeffs, size_t frameIdx);


    void checkRestrictions(const MultidimArray<T> &output,
                                        const MultidimArray<T> &input);

    void loadOutput(MultidimArray<T> &output, T outside);

    void loadInput(const MultidimArray<T> &input);

    void applyGeometry_2D_wrap(int SplineDegree);


    template<typename T_MAT>
    void loadTransform(const Matrix2D<T_MAT> &transform, bool isInv);

    void setDefaultValues();


    void test(const Matrix2D<T> &transform);

    void loadCoefficients(const Matrix1D<T> &X,
            const Matrix1D<T> &Y);

    void setOutputSize(MultidimArray<T> &output);


protected:
    /*
     * Reference computation used for the testing of a faster kernel
    */
    void applyBSplineTransformRef(int splineDegree,
            MultidimArray<T> &output, const MultidimArray<T> &input,
            const std::pair<Matrix1D<T>, Matrix1D<T>> &coeffs, size_t imageIdx, T outside = 0);

    void produceAndLoadCoeffs(const MultidimArray<T> &input);

    /*
    * Creates a copy of device input memory
    * Used in tests
    */
    std::unique_ptr<T[]> copy_out_d_in( size_t size ) const;

private:
    bool isReadyForMatrix;
    bool isReadyForBspline;

    T *d_trInv; // memory on GPU with inverse transformation (dest->src)
    T *d_in; // memory on GPU with input data
    T *d_out; // memory in GPU with output data

    T *d_coeffsX; // coefficients of the BSpline transformation, X direction
    T *d_coeffsY; // coefficients of the BSpline transformation, Y direction

    const GPU *gpu;

    // dimensions of the input/output data
    size_t inX;
    size_t inY;
    size_t inZ;
    size_t inN;

    // dimension of the coefficients control points
    size_t splineX;
    size_t splineY;
    size_t splineN;

    constexpr static const T transposeTileDim = (T)32;
    constexpr static const T transposeBlockRow = (T)8;
    constexpr static const int pixelsPerThread = 2;
};
#endif // CUDA_GEO_TRANSFORMER