#include <movie_alignment_correlation_base.h>

Inheritance diagram for AProgMovieAlignmentCorrelation< T >:

Collaboration diagram for AProgMovieAlignmentCorrelation< T >:

Public Member Functions
virtual void	readParams ()
	Read argument from command line. More...

virtual void	show ()
	Show. More...

virtual void	defineParams ()
	Define parameters. More...

void	run ()
	Run. More...

Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)

const char *	getParam (const char param, const char subparam, int arg=0)

int	getIntParam (const char *param, int arg=0)

int	getIntParam (const char param, const char subparam, int arg=0)

double	getDoubleParam (const char *param, int arg=0)

double	getDoubleParam (const char param, const char subparam, int arg=0)

float	getFloatParam (const char *param, int arg=0)

float	getFloatParam (const char param, const char subparam, int arg=0)

void	getListParam (const char *param, StringVector &list)

int	getCountParam (const char *param)

bool	checkParam (const char *param)

bool	existsParam (const char *param)

void	addParamsLine (const String &line)

void	addParamsLine (const char *line)

ParamDef *	getParamDef (const char *param) const

virtual void	quit (int exit_code=0) const

virtual int	tryRun ()

void	initProgress (size_t total, size_t stepBin=60)

void	setProgress (size_t value=0)

void	endProgress ()

void	processDefaultComment (const char param, const char left)

void	setDefaultComment (const char param, const char comment)

virtual void	initComments ()

void	setProgramName (const char *name)

void	addUsageLine (const char *line, bool verbatim=false)

void	clearUsage ()

void	addExampleLine (const char *example, bool verbatim=true)

void	addSeeAlsoLine (const char *seeAlso)

void	addKeywords (const char *keywords)

const char *	name () const

virtual void	usage (int verb=0) const

virtual void	usage (const String &param, int verb=2)

int	version () const

virtual void	show () const

virtual void	read (int argc, const char **argv, bool reportErrors=true)

virtual void	read (int argc, char **argv, bool reportErrors=true)

void	read (const String &argumentsLine)

	XmippProgram ()

	XmippProgram (int argc, const char **argv)

virtual	~XmippProgram ()

Protected Member Functions
Dimensions	getMovieSizeRaw ()

Dimensions	getMovieSize ()

AlignmentResult< T >	computeAlignment (Matrix1D< T > &bX, Matrix1D< T > &bY, Matrix2D< T > &A, const core::optional< size_t > &refFrame, size_t N, int verbose)

int	findReferenceImage (size_t N, const Matrix1D< T > &shiftX, const Matrix1D< T > &shiftY)

void	computeTotalShift (int iref, int j, const Matrix1D< T > &shiftX, const Matrix1D< T > &shiftY, T &totalShiftX, T &totalShiftY)

MultidimArray< T >	createLPF (T Ts, const Dimensions &dims)

void	loadFrame (const MetaData &movie, const Image< T > &dark, const Image< T > &igain, size_t objId, Image< T > &out) const

virtual void	applyShiftsComputeAverage (const MetaData &movie, const Image< T > &dark, const Image< T > &igain, Image< T > &initialMic, size_t &Ninitial, Image< T > &averageMicrograph, size_t &N, const AlignmentResult< T > &globAlignment)=0

virtual void	applyShiftsComputeAverage (const MetaData &movie, const Image< T > &dark, const Image< T > &igain, Image< T > &initialMic, size_t &Ninitial, Image< T > &averageMicrograph, size_t &N, const LocalAlignmentResult< T > &alignment)=0

virtual AlignmentResult< T >	computeGlobalAlignment (const MetaData &movie, const Image< T > &dark, const Image< T > &igain)=0

virtual LocalAlignmentResult< T >	computeLocalAlignment (const MetaData &movie, const Image< T > &dark, const Image< T > &igain, const AlignmentResult< T > &globAlignment)=0

virtual void	releaseAll ()=0

void	storeResults (const LocalAlignmentResult< T > &alignment)

float	getPixelResolution (float scaleFactor) const

float	getScaleFactor () const

std::pair< size_t, size_t >	getRequestedPatchSize () const

auto	getBinning () const

bool	applyBinning () const

Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes
int	nfirst

int	nlast

float	maxShift

FileName	fnAligned

FileName	fnAvg

int	nfirstSum

int	nlastSum

FileName	fnInitialAvg

std::pair< size_t, size_t >	localAlignPatches

Dimensions	localAlignmentControlPoints = Dimensions(0)

Protected Attributes inherited from XmippProgram
int	errorCode

ProgramDef *	progDef
	Program definition and arguments parser. More...

std::map< String, CommentList >	defaultComments

int	argc
	Original command line arguments. More...

const char **	argv

Static Protected Attributes
static constexpr int	solverIterations = 2

Additional Inherited Members
Public Attributes inherited from XmippProgram
bool	doRun

bool	runWithoutArgs

int	verbose
	Verbosity level. More...

int	debug

Detailed Description

template<typename T>
class AProgMovieAlignmentCorrelation< T >

Definition at line 56 of file movie_alignment_correlation_base.h.

Member Function Documentation

◆ applyBinning()

template<typename T >

bool AProgMovieAlignmentCorrelation< T >::applyBinning ( ) const

inlineprotected

Definition at line 227 of file movie_alignment_correlation_base.h.

                               {
         return binning != 1.0;
     }

◆ applyShiftsComputeAverage() [1/2]

template<typename T >

virtual void AProgMovieAlignmentCorrelation< T >::applyShiftsComputeAverage	(	const MetaData &	movie,
		const Image< T > &	dark,
		const Image< T > &	igain,
		Image< T > &	initialMic,
		size_t &	Ninitial,
		Image< T > &	averageMicrograph,
		size_t &	N,
		const AlignmentResult< T > &	globAlignment
	)

protectedpure virtual

This method applies global shifts and can also produce 'average' image (micrograph)

Parameters

movie	input
dark	correction to be used
igain	correction to be used
initialMic	sum of the unaligned micrographs
Ninitial	will store number of micrographs used for unaligned sum
averageMicrograph	sum of the aligned micrographs
N	will store number of micrographs used for aligned sum
globAlignment	to apply

◆ applyShiftsComputeAverage() [2/2]

template<typename T >

virtual void AProgMovieAlignmentCorrelation< T >::applyShiftsComputeAverage	(	const MetaData &	movie,
		const Image< T > &	dark,
		const Image< T > &	igain,
		Image< T > &	initialMic,
		size_t &	Ninitial,
		Image< T > &	averageMicrograph,
		size_t &	N,
		const LocalAlignmentResult< T > &	alignment
	)

protectedpure virtual

This method applies local shifts and can also produce 'average' image (micrograph)

Parameters

movie	input
dark	correction to be used
igain	correction to be used
initialMic	sum of the unaligned micrographs
Ninitial	will store number of micrographs used for unaligned sum
averageMicrograph	sum of the aligned micrographs
N	will store number of micrographs used for aligned sum
alignment	to apply

◆ computeAlignment()

template<typename T >

AlignmentResult< T > AProgMovieAlignmentCorrelation< T >::computeAlignment	(	Matrix1D< T > &	bX,
		Matrix1D< T > &	bY,
		Matrix2D< T > &	A,
		const core::optional< size_t > &	refFrame,
		size_t	N,
		int	verbose
	)

protected

Compute alignment of the each frame from frame-to-frame shifts

Parameters

bX	frame-to-frame shift in X dim
bY	frame-to-frame shift in Y dim
A	system matrix to be used
refFrame	reference frame
N	no of frames
verbose	level

Returns: respective global alignment

Definition at line 400 of file movie_alignment_correlation_base.cpp.

                                                                      {
     // now get the estimated shift (from the equation system)
     // from each frame to successive frame
     Matrix1D<T> shiftX, shiftY;
     EquationSystemSolver::solve(bX, bY, A, shiftX, shiftY, verbose, solverIterations);
     // prepare result
     AlignmentResult<T> result {.refFrame = refFrame ?
                     refFrame.value() :
                     this->findReferenceImage(N, shiftX, shiftY)};
     result.shifts.reserve(N);
     // compute total shift in respect to reference frame
     for (size_t i = 0; i < N; ++i) {
         T x, y;
         this->computeTotalShift(result.refFrame, i, shiftX, shiftY, x, y);
         result.shifts.emplace_back(x, y);
     }
     return result;
 }

◆ computeGlobalAlignment()

template<typename T >

virtual AlignmentResult<T> AProgMovieAlignmentCorrelation< T >::computeGlobalAlignment	(	const MetaData &	movie,
		const Image< T > &	dark,
		const Image< T > &	igain
	)

protectedpure virtual

This method computes global shift of the frames of the movie

Parameters

movie	to process
dark	pixel correction
igain	correction

Returns: global alignment of the movie

◆ computeLocalAlignment()

template<typename T >

virtual LocalAlignmentResult<T> AProgMovieAlignmentCorrelation< T >::computeLocalAlignment	(	const MetaData &	movie,
		const Image< T > &	dark,
		const Image< T > &	igain,
		const AlignmentResult< T > &	globAlignment
	)

protectedpure virtual

This method computes local shift of the frames of the movie

Parameters

movie	to process
dark	pixel correction
igain	correction

Returns: local alignment of the movie

◆ computeTotalShift()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::computeTotalShift	(	int	iref,
		int	j,
		const Matrix1D< T > &	shiftX,
		const Matrix1D< T > &	shiftY,
		T &	totalShiftX,
		T &	totalShiftY
	)

protected

Method to compute sum of shifts of some image in respect to a reference image

Parameters

iref	index of the reference image
j	index of the queried image
shiftX	relative shifts in X dim
shiftY	relative shifts in Y dim
totalShiftX	resulting shift in X dim
totalShiftY	resulting shift in Y dim

Definition at line 229 of file movie_alignment_correlation_base.cpp.

                         {
     totalShiftX = totalShiftY = 0;
     if (iref < j) {
         for (int jj = j - 1; jj >= iref; --jj) {
             totalShiftX -= shiftX(jj);
             totalShiftY -= shiftY(jj);
         }
     } else if (iref > j) {
         for (int jj = j; jj <= iref - 1; ++jj) {
             totalShiftX += shiftX(jj);
             totalShiftY += shiftY(jj);
         }
     }
 }

◆ createLPF()

template<typename T >

MultidimArray< T > AProgMovieAlignmentCorrelation< T >::createLPF	(	T	Ts,
		const Dimensions &	dims
	)

protected

Method will create a 2D Low Pass Filter of given size

Parameters

Ts	pixel resolution of the resulting filter
dims	dimension of the filter (in spatial domain)

Returns: requested LPF

Definition at line 185 of file movie_alignment_correlation_base.cpp.

                                                                                           {
     assert(Ts >= this->Ts);
 
     // Construct 1D profile of the lowpass filter
     MultidimArray<T> lpf(dims.x());
     createLPF(Ts, lpf);
 
     // scale 1D filter to 2D
     MultidimArray<T> result;
     result.initZeros(dims.y(), (dims.x() / 2) + 1);
     scaleLPF(lpf, dims, result);
     return result;
 }

◆ defineParams()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippProgram.

Reimplemented in ProgMovieAlignmentCorrelation< T >, and ProgMovieAlignmentCorrelationGPU< T >.

Definition at line 112 of file movie_alignment_correlation_base.cpp.

                                                      {
     addUsageLine("Align a set of frames by cross-correlation of the frames");
     addParamsLine(
             "   -i <metadata>               : Metadata with the list of frames to align");
     addParamsLine(
             "  [-o <fn=\"out.xmd\">]        : Metadata with the shifts of each frame.");
     addParamsLine(
             "                               : If no filename is given, the input is rewritten");
     addParamsLine(
             "  [--bin <s=1>]                : Binning factor, it may be any floating number > 1.");
     addParamsLine(
             "                               : Binning is applied during the data loading, i.e. the program will processed and store binned data.");
     addParamsLine(
             "  [--maxShift <s=50>]          : Maximum shift allowed in A");
     addParamsLine(
             "  [--maxResForCorrelation <R=30>]: Maximum resolution to align (in Angstroms)");
     addParamsLine(
             "  [--sampling <Ts=1>]          : Sampling rate (A/pixel)");
     addParamsLine(
             "  [--oaligned <fn=\"\">]       : Aligned movie consists of aligned frames used for micrograph generation");
     addParamsLine(
             "  [--oavgInitial <fn=\"\">]    : Give the name of a micrograph to generate an unaligned (initial) micrograph");
     addParamsLine(
             "  [--oavg <fn=\"\">]           : Give the name of a micrograph to generate an aligned micrograph");
     addParamsLine(
             "  [--frameRange <n0=-1> <nF=-1>]  : First and last frame to align, frame numbers start at 0");
     addParamsLine(
             "  [--frameRangeSum <n0=-1> <nF=-1>]  : First and last frame to sum, frame numbers start at 0");
     addParamsLine("  [--dark <fn=\"\">]           : Dark correction image");
     addParamsLine("  [--gain <fn=\"\">]           : Gain correction image (we will multiply by it)");
     addParamsLine(
             "  [--skipLocalAlignment]       : If used, only global alignment will be performed. It's faster, but gives worse results.");
     addParamsLine(
             "  [--controlPoints <x=6> <y=6> <t=5>]: Number of control points (including end points) used for defining the BSpline");
     addParamsLine(
             "  [--patches <x=7> <y=7>]: Number of patches used for local alignment");
     addParamsLine(
             "  [--minLocalRes <R=500>]      : Minimal resolution (in A) of patches during local alignment");
     addExampleLine("A typical example", false);
     addSeeAlsoLine("xmipp_movie_optical_alignment_cpu");
 }

◆ findReferenceImage()

template<typename T >

int AProgMovieAlignmentCorrelation< T >::findReferenceImage	(	size_t	N,
		const Matrix1D< T > &	shiftX,
		const Matrix1D< T > &	shiftY
	)

protected

Method finds a reference image, i.e. an image which has smallest relative shift to all other images.

Parameters

N	no of images
shiftX	relative X shift of each image
shiftY	relative Y shift of each image

Returns: position of the reference frame

Definition at line 247 of file movie_alignment_correlation_base.cpp.

                                                               {
     int bestIref = -1;
     // Choose reference image as the minimax of shifts
     T worstShiftEver = std::numeric_limits<T>::max();
     for (int iref = 0; iref < N; ++iref) {
         T worstShift = -1;
         for (int j = 0; j < N; ++j) {
             T totalShiftX, totalShiftY;
             computeTotalShift(iref, j, shiftX, shiftY, totalShiftX,
                     totalShiftY);
             if (fabs(totalShiftX) > worstShift)
                 worstShift = fabs(totalShiftX);
         }
         if (worstShift < worstShiftEver) {
             worstShiftEver = worstShift;
             bestIref = iref;
         }
     }
     return bestIref;
 }

◆ getBinning()

template<typename T >

auto AProgMovieAlignmentCorrelation< T >::getBinning ( ) const

inlineprotected

Get binning factor for resulting micrograph / alignend movie

Definition at line 223 of file movie_alignment_correlation_base.h.

                             {
         return binning;
     }

◆ getMovieSize()

template<typename T >

Dimensions AProgMovieAlignmentCorrelation< T >::getMovieSize ( )

protected

Returns: dimension of the movie frames and their count after binning, if applied

Definition at line 357 of file movie_alignment_correlation_base.cpp.

                                                            {
     if (movieSize) return movieSize.value();
     auto full = getMovieSizeRaw();
     if (applyBinning()) {
         // to make FFT fast, we want the size to be a multiple of 2
         auto x = ((static_cast<float>(full.x()) / binning) / 2.f) * 2.f;
         auto y = ((static_cast<float>(full.y()) / binning) / 2.f) * 2.f;
         movieSize = Dimensions(static_cast<size_t>(x), static_cast<size_t>(y), 1L, full.n());
     } else {
         movieSize = full;
     }
     return movieSize.value();
 }

◆ getMovieSizeRaw()

template<typename T >

Dimensions AProgMovieAlignmentCorrelation< T >::getMovieSizeRaw ( )

protected

Returns: dimension of the raw movie frames and their count (taking into account slicing indicated by the user)

Definition at line 339 of file movie_alignment_correlation_base.cpp.

                                                               {
     if (this->movieSizeRaw) return movieSizeRaw.value();
     int noOfImgs = this->nlast - this->nfirst + 1;
     auto fn = fnMovie;
     if (fnMovie.isMetaData()) {
         MetaDataVec md;
         md.read(fnMovie);
         md.getValue(MDL_IMAGE, fn, md.firstRowId()); // assuming all frames have the same resolution
     }
     ImageGeneric movieStack;
     movieStack.read(fn, HEADER);
     size_t xdim, ydim, zdim, ndim;
     movieStack.getDimensions(xdim, ydim, zdim, ndim);
     this->movieSizeRaw = Dimensions(xdim, ydim, 1, noOfImgs);
     return movieSizeRaw.value();
 }

◆ getPixelResolution()

template<typename T >

float AProgMovieAlignmentCorrelation< T >::getPixelResolution ( float scaleFactor ) const

protected

Returns pixel resolution of the scaled movie

Parameters

scaleFactor (<= 1) used to change size of the movie

Definition at line 180 of file movie_alignment_correlation_base.cpp.

                                                                                    {
     return this->Ts / scaleFactor;
 }

◆ getRequestedPatchSize()

template<typename T >

std::pair<size_t, size_t> AProgMovieAlignmentCorrelation< T >::getRequestedPatchSize ( ) const

inlineprotected

Returns size of the patch as requested by user

Definition at line 217 of file movie_alignment_correlation_base.h.

                                                           {
         return {minLocalRes / Ts, minLocalRes / Ts};
     }

◆ getScaleFactor()

template<typename T >

float AProgMovieAlignmentCorrelation< T >::getScaleFactor ( ) const

protected

Returns scale factor as requested by user

Definition at line 311 of file movie_alignment_correlation_base.cpp.

                                                               {
     // scale is ration between original pixel size and new pixel size
     return Ts / getTsPrime();
 }

◆ loadFrame()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::loadFrame	(	const MetaData &	movie,
		const Image< T > &	dark,
		const Image< T > &	igain,
		size_t	objId,
		Image< T > &	out
	)		const

protected

Method loads a single frame from the movie and apply gain and dark pixel correction

Parameters

movie	to load from
dark	pixel correction
igain	inverse gain correction
objId	id of the image to load
out	loaded frame

Definition at line 155 of file movie_alignment_correlation_base.cpp.

                                  {
     FileName fnFrame;
     movie.getValue(MDL_IMAGE, fnFrame, objId);
     out.read(fnFrame);
     if (XSIZE(dark()) > 0) {
         if ((XSIZE(dark()) != XSIZE(out()))
                 || (YSIZE(dark()) != YSIZE(out()))) {
             REPORT_ERROR(ERR_ARG_INCORRECT,
                             "The dark image size does not match the movie frame size.");
         }
         out() -= dark();
     }
     if (XSIZE(igain()) > 0) {
         if ((XSIZE(igain()) != XSIZE(out()))
                 || (YSIZE(igain()) != YSIZE(out()))) {
             REPORT_ERROR(ERR_ARG_INCORRECT,
                             "The gain image size does not match the movie frame size.");
         }
         out() *= igain();
     }
 }

◆ readParams()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::readParams ( )

virtual

Read argument from command line.

Reimplemented from XmippProgram.

Reimplemented in ProgMovieAlignmentCorrelation< T >, and ProgMovieAlignmentCorrelationGPU< T >.

Definition at line 33 of file movie_alignment_correlation_base.cpp.

                                                    {
     fnMovie = getParam("-i");
     fnOut = getParam("-o");
     fnInitialAvg = getParam("--oavgInitial");
     fnDark = getParam("--dark");
     fnGain = getParam("--gain");
     binning = getFloatParam("--bin");
     if (binning < 1.0)
         REPORT_ERROR(ERR_ARG_INCORRECT, "Binning must be >= 1");
     Ts = getFloatParam("--sampling") * binning;
     maxShift = getFloatParam("--maxShift") / Ts;
     maxResForCorrelation = getFloatParam("--maxResForCorrelation");
     fnAligned = getParam("--oaligned");
     fnAvg = getParam("--oavg");
     nfirst = getIntParam("--frameRange", 0);
     nlast = getIntParam("--frameRange", 1);
     nfirstSum = getIntParam("--frameRangeSum", 0);
     nlastSum = getIntParam("--frameRangeSum", 1);
     skipLocalAlignment = checkParam("--skipLocalAlignment");
     minLocalRes = getIntParam("--minLocalRes");
 
     // read control points
     Dimensions cPoints(
             this->getIntParam("--controlPoints", 0),
             this->getIntParam("--controlPoints", 1),
             1,
             this->getIntParam("--controlPoints", 2));
     if ((cPoints.x() < 3) || (cPoints.y() < 3) || (cPoints.n() < 3))
         REPORT_ERROR(ERR_ARG_INCORRECT,
             "All control points has to be bigger than 2");
     localAlignmentControlPoints = cPoints;
 
 }

◆ releaseAll()

template<typename T >

virtual void AProgMovieAlignmentCorrelation< T >::releaseAll ( )

protectedpure virtual

This method releases all resources allocated so far

◆ run()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::run ( )

virtual

Run.

Reimplemented from XmippProgram.

Definition at line 530 of file movie_alignment_correlation_base.cpp.

                                             {
     // preprocess input data
     MetaDataVec movie;
     readMovie(movie);
     correctLoopIndices(movie);
 
     setNoOfPatches();
     show();
     checkSettings();
 
     Image<T> dark, igain;
     loadDarkCorrection(dark);
     loadGainCorrection(igain);
 
     auto globalAlignment = AlignmentResult<T>();
     std::cout << "Computing global alignment ...\n";
     globalAlignment = computeGlobalAlignment(movie, dark, igain);
 
     if ( ! fnOut.isEmpty()) {
         storeGlobalShifts(globalAlignment, movie);
     }
 
     if (verbose) printGlobalShift(globalAlignment);
 
     size_t N, Ninitial;
     Image<T> initialMic, averageMicrograph;
     // Apply shifts and compute average
     if (skipLocalAlignment) {
         applyShiftsComputeAverage(movie, dark, igain, initialMic, Ninitial,
                     averageMicrograph, N, globalAlignment);
     } else {
         std::cout << "Computing local alignment ...\n";
         auto localAlignment = computeLocalAlignment(movie, dark, igain, globalAlignment);
         applyShiftsComputeAverage(movie, dark, igain, initialMic, Ninitial,
                     averageMicrograph, N, localAlignment);
         storeResults(localAlignment);
     }
 
     storeResults(initialMic, Ninitial, averageMicrograph, N, movie, globalAlignment.refFrame);
 
     releaseAll();
 }

◆ show()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::show ( )

virtual

Show.

Reimplemented in ProgMovieAlignmentCorrelationGPU< T >.

Definition at line 89 of file movie_alignment_correlation_base.cpp.

                                              {
     if (!verbose)
         return;
     std::cout
             << "Input movie:           " << fnMovie << std::endl
             << "Output metadata:       " << fnOut << std::endl
             << "Dark image:            " << fnDark << std::endl
             << "Gain image:            " << fnGain << std::endl
             << "Max. Shift (A / px):   " << (maxShift * Ts) << " / " << maxShift << std::endl
             << "Max resolution (A):    " << maxResForCorrelation << std::endl
             << "Sampling:              " << Ts << std::endl
             << "Aligned movie:         " << fnAligned << std::endl
             << "Aligned micrograph:    " << fnAvg << std::endl
             << "Unaligned micrograph:  " << fnInitialAvg << std::endl
             << "Frame range alignment: " << nfirst << " " << nlast << std::endl
             << "Frame range sum:       " << nfirstSum << " " << nlastSum << std::endl
             << "Binning factor:        " << binning << std::endl
             << "Skip local alignment:  " << (skipLocalAlignment ? "yes" : "no") << std::endl
             << "Control points:        " << this->localAlignmentControlPoints << std::endl
             << "No of patches:         " << this->localAlignPatches.first << " * " << localAlignPatches.second << std::endl;
 }

◆ storeResults()

template<typename T >

void AProgMovieAlignmentCorrelation< T >::storeResults ( const LocalAlignmentResult< T > & alignment )

protected

Method to store all computed alignment to hard drive

Definition at line 462 of file movie_alignment_correlation_base.cpp.

                                                   {
     if (fnOut.isEmpty()) {
         return;
     }
     if ( ! alignment.bsplineRep) {
         REPORT_ERROR(ERR_VALUE_INCORRECT,
             "Missing BSpline representation. This should not happen. Please contact developers.");
     }
     // Store average
     std::vector<double> shifts;
     for (auto &&p : alignment.shifts) {
         int tileCenterX = p.first.rec.getCenter().x;
         int tileCenterY = p.first.rec.getCenter().y;
         int tileIdxT = p.first.id_t;
         auto shift = BSplineHelper::getShift(
                 alignment.bsplineRep.value(), alignment.movieDim,
                 tileCenterX, tileCenterY, tileIdxT);
         auto globalShift = alignment.globalHint.shifts.at(tileIdxT);
         shifts.emplace_back(hypot(shift.first - globalShift.x, shift.second - globalShift.y));
     }
     MetaDataVec mdIref;
     size_t id = mdIref.addObject();
     // Store confidence interval
     std::sort(shifts.begin(), shifts.end(), std::less<double>());
     size_t indexL = shifts.size() * 0.025;
     size_t indexU = shifts.size() * 0.975;
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_CONF_2_5_PERC, shifts.at(indexL), id);
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_CONF_97_5_PERC, shifts.at(indexU), id);
     // Store patches
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_PATCHES,
         std::vector<size_t>{localAlignPatches.first, localAlignPatches.second}, id);
     // Store coefficients
     std::vector<double> tmpX;
     std::vector<double> tmpY;
     size_t size = alignment.bsplineRep.value().getCoeffsX().size();
     for (int i = 0; i < size; ++i) {
         tmpX.push_back(alignment.bsplineRep.value().getCoeffsX()(i));
         tmpY.push_back(alignment.bsplineRep.value().getCoeffsY()(i));
     }
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_COEFFS_X, tmpX, id);
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_COEFFS_Y, tmpY, id);
     // Store control points
     mdIref.setValue(MDL_LOCAL_ALIGNMENT_CONTROL_POINTS,
             std::vector<size_t>{
                 localAlignmentControlPoints.x(),
                 localAlignmentControlPoints.y(),
                 localAlignmentControlPoints.n()},
             id);
     // Safe to file
     mdIref.write("localAlignment@" + fnOut, MD_APPEND);
 }

◆ nlastSum

template<typename T >

int AProgMovieAlignmentCorrelation< T >::nlastSum

protected

Definition at line 324 of file movie_alignment_correlation_base.h.

◆ solverIterations

template<typename T >

constexpr int AProgMovieAlignmentCorrelation< T >::solverIterations = 2

staticprotected

Solver iterations

Definition at line 332 of file movie_alignment_correlation_base.h.

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

xmipp/libraries/reconstruction/movie_alignment_correlation_base.h
xmipp/libraries/reconstruction/movie_alignment_correlation_base.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

template<typename T> class AProgMovieAlignmentCorrelation< T >

Member Function Documentation

◆ applyBinning()

◆ applyShiftsComputeAverage() [1/2]

◆ applyShiftsComputeAverage() [2/2]

◆ computeAlignment()

◆ computeGlobalAlignment()

◆ computeLocalAlignment()

◆ computeTotalShift()

◆ createLPF()

◆ defineParams()

◆ findReferenceImage()

◆ getBinning()

◆ getMovieSize()

◆ getMovieSizeRaw()

◆ getPixelResolution()

◆ getRequestedPatchSize()

◆ getScaleFactor()

◆ loadFrame()

◆ readParams()

◆ releaseAll()

◆ run()

◆ show()

◆ storeResults()

Member Data Documentation

◆ fnAligned

◆ fnAvg

◆ fnInitialAvg

◆ localAlignmentControlPoints

◆ localAlignPatches

◆ maxShift

◆ nfirst

◆ nfirstSum

◆ nlast

◆ nlastSum

◆ solverIterations

template<typename T>
class AProgMovieAlignmentCorrelation< T >