BSplineHelper Class Reference

#include <bspline_helper.h>

Static Public Member Functions
template<typename T >
static std::pair< Matrix1D< T >, Matrix1D< T > >	computeBSplineCoeffs (const Dimensions &movieSize, const LocalAlignmentResult< T > &alignment, const Dimensions &controlPoints, const std::pair< size_t, size_t > &noOfPatches, int verbosity, int solverIters)
template<typename T >
static std::pair< T, T >	getShift (const BSplineGrid< T > &grid, Dimensions dim, size_t x, size_t y, size_t n)
template<typename T >
static T	Bspline03 (T argument)
template<typename T >
static void	getShift (int lX, int lY, int lN, int xdim, int ydim, int ndim, int x, int y, int n, T &shiftY, T &shiftX, const T *coeffsX, const T *coeffsY)

Detailed Description

Definition at line 41 of file bspline_helper.h.

Member Function Documentation

Bspline03()

template<typename T >

static T BSplineHelper::Bspline03 ( T  argument )

inlinestatic

Interpolate by cubic BSpline

Parameters

argument

to interpolate

Definition at line 78 of file bspline_helper.h.

                                          {

        static_assert(std::is_same<float, T>::value
                || std::is_same<double, T>::value, "T must be either float or double");
        if (std::is_same<float, T>::value) {
            argument = fabsf(argument);
        } else {
            argument = fabs(argument);
        }
        if (argument < (T)1) {
            return(argument * argument * (argument - (T)2) * (T)0.5 + (T)2 / (T)3);
        }
        else if (argument < (T)2) {
            argument -= (T)2;
            return(argument * argument * argument * ((T)-1 / (T)6));
        }
        else {
            return (T)0;
        }
    }

computeBSplineCoeffs()

template<typename T >

std::pair< Matrix1D< T >, Matrix1D< T > > BSplineHelper::computeBSplineCoeffs ( const Dimensions &  movieSize, const LocalAlignmentResult< T > &  alignment, const Dimensions &  controlPoints, const std::pair< size_t, size_t > &  noOfPatches, int  verbosity, int  solverIters  )

static

Computes BSpline coefficients from given data

Parameters

movieSize
alignment	to use
controlPoints	of the resulting spline
noOfPatches	used for generating the alignment
verbosity	level
solverIters	max iterations of the solver

Returns

coefficients of the BSpline representing the local shifts

Definition at line 34 of file bspline_helper.cpp.

                                        {
    if(verbosity) std::cout << "Computing BSpline coefficients" << std::endl;
        // get coefficients of the BSpline that can represent the shifts (formula  from the paper)
        int lX = controlPoints.x();
        int lY = controlPoints.y();
        int lT = controlPoints.n();
        int noOfPatchesXY = noOfPatches.first * noOfPatches.second;
        Matrix2D<T>A(noOfPatchesXY*movieSize.n(), lX * lY * lT);
        Matrix1D<T>bX(noOfPatchesXY*movieSize.n());
        Matrix1D<T>bY(noOfPatchesXY*movieSize.n());
        T hX = (lX == 3) ? movieSize.x() : (movieSize.x() / (T)(lX-3));
        T hY = (lY == 3) ? movieSize.y() : (movieSize.y() / (T)(lY-3));
        T hT = (lT == 3) ? movieSize.n() : (movieSize.n() / (T)(lT-3));

        for (auto &&r : alignment.shifts) {
            auto meta = r.first;
            auto shift = r.second;
            int tileIdxT = meta.id_t;
            int tileCenterT = tileIdxT * 1 + 0 + 0;
            int tileIdxX = meta.id_x;
            int tileIdxY = meta.id_y;
            int tileCenterX = meta.rec.getCenter().x;
            int tileCenterY = meta.rec.getCenter().y;
            int i = (tileIdxY * noOfPatches.first) + tileIdxX;

            for(int controlIdxT = -1; controlIdxT < (lT - 1); ++controlIdxT) {
                T tmpT = Bspline03((tileCenterT / hT) - controlIdxT);
                if (tmpT == (T)0) continue;
                for(int controlIdxY = -1; controlIdxY < (lY - 1); ++controlIdxY) {
                    T tmpY = Bspline03((tileCenterY / hY) - controlIdxY);
                    if (tmpY == (T)0) continue;
                    for(int controlIdxX = -1; controlIdxX < (lX - 1); ++controlIdxX) {
                        T tmpX = Bspline03((tileCenterX / hX) - controlIdxX);
                        T val = tmpT * tmpY * tmpX;
                        int j = ((controlIdxT + 1) * lX * lY) +
                                ((controlIdxY + 1) * lX) + (controlIdxX + 1);
                        MAT_ELEM(A,tileIdxT*noOfPatchesXY + i, j) = val;
                    }
                }
            }
            VEC_ELEM(bX,tileIdxT*noOfPatchesXY + i) = -shift.x; // we want the BSPline describing opposite transformation,
            VEC_ELEM(bY,tileIdxT*noOfPatchesXY + i) = -shift.y; // so that we can use it to compensate for the shift
        }

        // solve the equation system for the spline coefficients
        Matrix1D<T> coefsX;
        Matrix1D<T> coefsY;
        EquationSystemSolver::solve(bX, bY, A, coefsX, coefsY, verbosity + 1, solverIters);
        return std::make_pair(coefsX, coefsY);
}

getShift() [1/2]

template<typename T >

std::pair< T, T > BSplineHelper::getShift ( const BSplineGrid< T > &  grid, Dimensions  dim, size_t  x, size_t  y, size_t  n  )

static

Get shift of the particular point using BSpline interpolation

Parameters

grid	used for interpolation
dim	of the original problem
x	queried position
y	queried position
n	queried position

Returns

shifted position

Definition at line 95 of file bspline_helper.cpp.

                                      {
    T shiftX = 0;
    T shiftY = 0;
    getShift(grid.getDim().x(), grid.getDim().y(), grid.getDim().n(),
            dim.x(), dim.y(), dim.n(),
            x, y, n,
            shiftX, shiftY,
            grid.getCoeffsX().vdata, grid.getCoeffsY().vdata);

    return std::make_pair(shiftX, shiftY);
}

getShift() [2/2]

template<typename T >

void BSplineHelper::getShift ( int  lX, int  lY, int  lN, int  xdim, int  ydim, int  ndim, int  x, int  y, int  n, T &  shiftY, T &  shiftX, const T *  coeffsX, const T *  coeffsY  )

static

Get shift of the particular point using BSpline interpolation

Parameters

lX	no of control points in X (including end points)
lY	no of control points in Y (including end points)
lN	no of control points in N (including end points)
xdim	size of the input
ydim	size of the input
ndim	size of the input
x	queried position
y	queried position
n	queried position
shiftX	shifted position
shiftY	shifted position
coeffsX	BSpline coefficients
coeffsY	BSpline coefficients

Definition at line 109 of file bspline_helper.cpp.

                                            {
    using std::max;
    using std::min;

    T delta = 0.0001;
    // take into account end points
    T hX = (lX == 3) ? xdim : (xdim / (T) (lX - 3));
    T hY = (lY == 3) ? ydim : (ydim / (T) (lY - 3));
    T hT = (lN == 3) ? ndim : (ndim / (T) (lN - 3));
    // index of the 'cell' where pixel is located (<0, N-3> for N control points)
    T xPos = x / hX;
    T yPos = y / hY;
    T tPos = n / hT;
    // indices of the control points are from -1 .. N-2 for N points
    // pixel in 'cell' 0 may be influenced by points with indices <-1,2>
    for (int idxT = max(-1, (int) (tPos) - 1);
            idxT <= min((int) (tPos) + 2, lN - 2);
            ++idxT) {
        T tmpT = Bspline03(tPos - idxT);
        for (int idxY = max(-1, (int) (yPos) - 1);
                idxY <= min((int) (yPos) + 2, lY - 2);
                ++idxY) {
            T tmpY = Bspline03(yPos - idxY);
            for (int idxX = max(-1, (int) (xPos) - 1);
                    idxX <= min((int) (xPos) + 2, lX - 2);
                    ++idxX) {
                T tmpX = Bspline03(xPos - idxX);
                T tmp = tmpX * tmpY * tmpT;
                if (fabsf(tmp) > delta) {
                    size_t coeffOffset = (idxT + 1) * (lX * lY)
                            + (idxY + 1) * lX + (idxX + 1);
                    shiftX += coeffsX[coeffOffset] * tmp;
                    shiftY += coeffsY[coeffOffset] * tmp;
                }
            }
        }
    }
}

---

The documentation for this class was generated from the following files:

• xmipp/libraries/reconstruction/bspline_helper.h
• xmipp/libraries/reconstruction/bspline_helper.cpp