#include <forward_zernike_images_priors.h>

Inheritance diagram for ProgForwardZernikeImagesPriors:

Collaboration diagram for ProgForwardZernikeImagesPriors:

Public Types
enum	Direction { Direction::ROTATE, Direction::UNROTATE }

Public Member Functions
	ProgForwardZernikeImagesPriors ()
	Empty constructor. More...

	~ProgForwardZernikeImagesPriors ()
	Destructor. More...

void	readParams ()
	Read argument from command line. More...

void	show ()
	Show. More...

void	defineParams ()
	Define parameters. More...

void	preProcess ()

void	processImage (const FileName &fnImg, const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut)

void	numCoefficients (int l1, int l2, int &vecSize)
	Length of coefficients vector. More...

void	minimizepos (Matrix1D< double > &steps)
	Determine the positions to be minimize of a vector containing spherical harmonic coefficients. More...

void	fillVectorTerms (int l1, int l2, Matrix1D< int > &vL1, Matrix1D< int > &vN, Matrix1D< int > &vL2, Matrix1D< int > &vM)
	Zernike and SPH coefficients allocation. More...

void	deformVol (MultidimArray< double > &mVD, const MultidimArray< double > &mV, double &def, double rot, double tilt, double psi)
	Deform a volumen using Zernike-Spherical harmonic basis. More...

void	updateCTFImage (double defocusU, double defocusV, double angle)

double	transformImageSph (double *pc_priors)

virtual void	finishProcessing ()

virtual void	writeImageParameters (MDRow &row)

virtual void	checkPoint ()
	For very long programs, it may be needed to write checkpoints. More...

Matrix1D< double >	weightsInterpolation3D (double x, double y, double z)

void	splattingAtPos (std::array< double, 3 > r, double weight, MultidimArray< double > &mP, const MultidimArray< double > &mV)

std::vector< double >	string2vector (std::string const &s) const

void	linearCombinationClnm ()

void	optimalPowellOrder ()

double	bspline1 (double x)

Public Member Functions inherited from XmippMetadataProgram
MetaData *	getInputMd ()

MetaDataVec &	getOutputMd ()

	XmippMetadataProgram ()
	Empty constructor. More...

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

virtual void	init ()

virtual void	setup (MetaData *md, const FileName &o="", const FileName &oroot="", bool applyGeo=false, MDLabel label=MDL_IMAGE)

virtual	~XmippMetadataProgram ()

void	setMode (WriteModeMetaData _mode)

void	setupRowOut (const FileName &fnImgIn, const MDRow &rowIn, const FileName &fnImgOut, MDRow &rowOut) const
	Prepare rowout. More...

virtual void	wait ()
	Wait for the distributor to finish. More...

virtual void	run ()
	Run over all images. 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)

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	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 ()

Public Attributes
FileName	fnVolR

FileName	fnMaskR

FileName	fnPriors

FileName	fnOutDir
	Output directory. More...

int	L1

int	L2

Matrix1D< int >	vL1

Matrix1D< int >	vN

Matrix1D< int >	vL2

Matrix1D< int >	vM

double	maxShift

double	maxAngularChange

double	maxResol

double	Ts

int	Rmax

bool	optimizeAlignment

bool	optimizeDefocus

bool	ignoreCTF

bool	optimizeRadius

bool	phaseFlipped

double	lambda

int	RmaxDef

int	num_images

int	algn_params

int	ctf_params

Matrix1D< double >	p

int	flagEnabled

int	image_mode

bool	useCTF

bool	resume

MultidimArray< int >	mask2D

MultidimArray< int >	V_mask

std::vector< std::vector< double > >	priors

size_t	Xdim

std::vector< FileName >	fnImage

Image< double >	V

Image< double >	Vdeformed

std::vector< Image< double > >	I

std::vector< Image< double > >	Ifiltered

std::vector< Image< double > >	Ifilteredp

std::vector< Image< double > >	P

FourierFilter	filter

Matrix2D< double >	A1

Matrix2D< double >	A2

Matrix2D< double >	A3

std::vector< double >	old_rot

std::vector< double >	old_tilt

std::vector< double >	old_psi

std::vector< double >	deltaRot

std::vector< double >	deltaTilt

std::vector< double >	deltaPsi

std::vector< double >	old_shiftX

std::vector< double >	old_shiftY

std::vector< double >	deltaX

std::vector< double >	deltaY

bool	old_flip

bool	hasCTF

std::vector< double >	old_defocusU

std::vector< double >	old_defocusV

std::vector< double >	old_defocusAngle

std::vector< double >	deltaDefocusU

std::vector< double >	deltaDefocusV

std::vector< double >	deltaDefocusAngle

std::vector< double >	currentDefocusU

std::vector< double >	currentDefocusV

std::vector< double >	currentAngle

FourierFilter	FilterCTF1

FourierFilter	FilterCTF2

FourierFilter	FilterCTF3

int	vecSize

Matrix1D< double >	c_priors

Matrix1D< double >	clnm

Matrix1D< double >	steps_cp

double	totalDeformation

double	prior_deformation

std::vector< double >	prior_deformations

bool	showOptimization

double	correlation

int	loop_step

struct blobtype	blob

double	blob_r

bool	do_not_init

Public Attributes inherited from XmippMetadataProgram
FileName	fn_in
	Filenames of input and output Metadata. More...

FileName	fn_out

FileName	baseName

FileName	pathBaseName

FileName	oextBaseName

bool	apply_geo
	Apply geo. More...

size_t	ndimOut
	Output dimensions. More...

size_t	zdimOut

size_t	ydimOut

size_t	xdimOut

DataType	datatypeOut

size_t	mdInSize
	Number of input elements. More...

Public Attributes inherited from XmippProgram
bool	doRun

bool	runWithoutArgs

int	verbose
	Verbosity level. More...

int	debug

Protected Member Functions
void	createWorkFiles ()

Protected Member Functions inherited from XmippMetadataProgram
virtual void	initComments ()

virtual void	postProcess ()

virtual bool	getImageToProcess (size_t &objId, size_t &objIndex)

void	show () const override

virtual void	startProcessing ()

virtual void	writeOutput ()

virtual void	showProgress ()

virtual void	defineLabelParam ()

Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Member Functions inherited from Rerunable
	Rerunable (const FileName &fn)

virtual void	createWorkFiles (bool resume, MetaData *md)

const FileName &	getFileName () const

void	setFileName (const FileName &fn)

Additional Inherited Members
Protected Attributes inherited from XmippMetadataProgram
WriteModeMetaData	mode
	Metadata writing mode: OVERWRITE, APPEND. More...

FileName	oext
	Output extension and root. More...

FileName	oroot

MDLabel	image_label
	MDLabel to be used to read/write images, usually will be MDL_IMAGE. More...

bool	produces_an_output
	Indicate that a unique final output is produced. More...

bool	produces_a_metadata
	Indicate that the unique final output file is a Metadata. More...

bool	each_image_produces_an_output
	Indicate that an output is produced for each image in the input. More...

bool	allow_apply_geo

bool	decompose_stacks
	Input Metadata will treat a stack file as a set of images instead of a unique file. More...

bool	delete_output_stack
	Delete previous output stack file prior to process images. More...

bool	get_image_info
	Get the input image file dimensions to further operations. More...

bool	save_metadata_stack
	Save the associated output metadata when output file is a stack. More...

bool	track_origin
	Include the original input image filename in the output stack. More...

bool	keep_input_columns
	Keep input metadata columns. More...

bool	remove_disabled
	Remove disabled images from the input selfile. More...

bool	allow_time_bar
	Show process time bar. More...

bool	input_is_metadata
	Input is a metadata. More...

bool	single_image
	Input is a single image. More...

bool	input_is_stack
	Input is a stack. More...

bool	output_is_stack
	Output is a stack. More...

bool	create_empty_stackfile

bool	delete_mdIn

size_t	time_bar_step
	Some time bar related counters. More...

size_t	time_bar_size

size_t	time_bar_done

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

Detailed Description

Predict Continuous Parameters.

Definition at line 43 of file forward_zernike_images_priors.h.

Member Enumeration Documentation

◆ Direction

enum ProgForwardZernikeImagesPriors::Direction

strong

Enumerator
ROTATE
UNROTATE

Definition at line 154 of file forward_zernike_images_priors.h.

154 { ROTATE, UNROTATE };

Constructor & Destructor Documentation

◆ ProgForwardZernikeImagesPriors()

ProgForwardZernikeImagesPriors::ProgForwardZernikeImagesPriors ( )

Empty constructor.

Definition at line 36 of file forward_zernike_images_priors.cpp.

                                                                : Rerunable("")
 {
     resume = false;
     produces_a_metadata = true;
     each_image_produces_an_output = false;
     showOptimization = false;
 }

◆ ~ProgForwardZernikeImagesPriors()

ProgForwardZernikeImagesPriors::~ProgForwardZernikeImagesPriors ( )

default

Destructor.

Member Function Documentation

◆ bspline1()

double ProgForwardZernikeImagesPriors::bspline1 ( double x )

Definition at line 1279 of file forward_zernike_images_priors.cpp.

 {
     double m = 1 / blob_r;
     if (0. < x && x < blob_r)
         return m * (blob_r - x);
     else if (-blob_r < x && x <= 0.)
         return m * (blob_r + x);
     else
         return 0.;
 }

◆ checkPoint()

void ProgForwardZernikeImagesPriors::checkPoint ( )

virtual

For very long programs, it may be needed to write checkpoints.

Reimplemented from XmippMetadataProgram.

Reimplemented in MpiProgForwardZernikeImagesPriors.

Definition at line 905 of file forward_zernike_images_priors.cpp.

                                                 {
     MDRowVec rowAppend;
     MetaDataVec checkPoint;
     getOutputMd().getRow(rowAppend, getOutputMd().lastRowId());
     checkPoint.addRow(rowAppend);
     checkPoint.append(Rerunable::getFileName());
 }

◆ createWorkFiles()

void ProgForwardZernikeImagesPriors::createWorkFiles ( )

inlineprotected

Definition at line 222 of file forward_zernike_images_priors.h.

222 { return Rerunable::createWorkFiles(resume, getInputMd()); }

Rerunable::createWorkFiles

virtual void createWorkFiles(bool resume, MetaData *md)

Definition: rerunable_program.h:49

XmippMetadataProgram::getInputMd

MetaData * getInputMd()

Definition: xmipp_metadata_program.h:58

ProgForwardZernikeImagesPriors::resume

bool resume

Definition: forward_zernike_images_priors.h:95

◆ defineParams()

void ProgForwardZernikeImagesPriors::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippMetadataProgram.

Definition at line 105 of file forward_zernike_images_priors.cpp.

 {
     addUsageLine("Make a continuous angular assignment with deformations");
     defaultComments["-i"].clear();
     defaultComments["-i"].addComment("Metadata with initial alignment");
     defaultComments["-o"].clear();
     defaultComments["-o"].addComment("Metadata with the angular alignment and deformation parameters");
     XmippMetadataProgram::defineParams();
     addParamsLine("   --ref <volume>              : Reference volume");
     addParamsLine("   --priors <metadata_file>    : List of priors (deformation coefficients)");
     addParamsLine("  [--mask <m=\"\">]            : Reference volume");
     addParamsLine("  [--odir <outputDir=\".\">]   : Output directory");
     addParamsLine("  [--max_shift <s=-1>]         : Maximum shift allowed in pixels");
     addParamsLine("  [--max_angular_change <a=5>] : Maximum angular change allowed (in degrees)");
     addParamsLine("  [--max_resolution <f=4>]     : Maximum resolution (A)");
     addParamsLine("  [--sampling <Ts=1>]          : Sampling rate (A/pixel)");
     addParamsLine("  [--Rmax <R=-1>]              : Maximum radius (px). -1=Half of volume size");
     addParamsLine("  [--RDef <r=-1>]              : Maximum radius of the deformation (px). -1=Half of volume size");
     addParamsLine("  [--l1 <l1=3>]                : Degree Zernike Polynomials=1,2,3,...");
     addParamsLine("  [--l2 <l2=2>]                : Harmonical depth of the deformation=1,2,3,...");
     addParamsLine("  [--regularization <l=0.005>] : Regularization weight");
     addParamsLine("  [--step <step=1>]            : Voxel index step");
     addParamsLine("  [--useCTF]                   : Correct CTF");
     addParamsLine("  [--optimizeAlignment]        : Optimize alignment");
     addParamsLine("  [--optimizeDefocus]          : Optimize defocus");
     addParamsLine("  [--phaseFlipped]             : Input images have been phase flipped");
     addParamsLine("  [--blobr <b=1.5>]            : Blob radius for forward mapping splatting");
     addParamsLine("  [--image_mode <im=-1>]       : Image mode (single, pairs, triplets). By default, it will be automatically identified.");
     addParamsLine("  [--resume]                   : Resume processing");
     addExampleLine("A typical use is:",false);
     addExampleLine("xmipp_angular_sph_alignment -i anglesFromContinuousAssignment.xmd --ref reference.vol -o assigned_anglesAndDeformations.xmd --optimizeAlignment --optimizeDeformation --depth 1");
 }

◆ deformVol()

void ProgForwardZernikeImagesPriors::deformVol	(	MultidimArray< double > &	mVD,
		const MultidimArray< double > &	mV,
		double &	def,
		double	rot,
		double	tilt,
		double	psi
	)

Deform a volumen using Zernike-Spherical harmonic basis.

Definition at line 969 of file forward_zernike_images_priors.cpp.

 {
     size_t idxY0=vecSize;
     double Ncount=0.0;
     double modg=0.0;
     double diff2=0.0;
 
     def=0.0;
     size_t idxZ0=2*idxY0;
     double RmaxF=RmaxDef;
     double RmaxF2=RmaxF*RmaxF;
     double iRmaxF=1.0/RmaxF;
     // Rotation Matrix
     Matrix2D<double> R;
     R.initIdentity(3);
     Euler_angles2matrix(rot, tilt, psi, R, false);
 
     // TODO: Poner primero i y j en el loop, acumular suma y guardar al final
     const auto lastZ = FINISHINGZ(mV);
     const auto lastY = FINISHINGY(mV);
     const auto lastX = FINISHINGX(mV);
     for (int k=STARTINGZ(mV); k<=lastZ; k+=loop_step)
     {
         for (int i=STARTINGY(mV); i<=lastY; i+=loop_step)
         {
             for (int j=STARTINGX(mV); j<=lastX; j+=loop_step)
             {
                 if (A3D_ELEM(V_mask,k,i,j) == 1) {
                     double gx=0.0, gy=0.0, gz=0.0;
                     double k2=k*k;
                     double kr=k*iRmaxF;
                     double k2i2=k2+i*i;
                     double ir=i*iRmaxF;
                     double r2=k2i2+j*j;
                     double jr=j*iRmaxF;
                     double rr=sqrt(r2)*iRmaxF;
                     for (size_t idx = 0; idx < idxY0; idx++)
                     {
                         auto l1 = VEC_ELEM(vL1,idx);
                         auto n = VEC_ELEM(vN,idx);
                         auto l2 = VEC_ELEM(vL2,idx);
                         auto m = VEC_ELEM(vM,idx);
                         auto zsph=ZernikeSphericalHarmonics(l1,n,l2,m,jr,ir,kr,rr);
                         auto c = std::array<double, 3>{};
                         c[0] = VEC_ELEM(clnm,idx);
                         c[1] = VEC_ELEM(clnm,idx+idxY0);
                         c[2] = VEC_ELEM(clnm,idx+idxZ0);
                         if (rr>0 || l2==0) {
                             gx += c[0]  *(zsph);
                             gy += c[1]  *(zsph);
                             gz += c[2]  *(zsph);
                         }
                     }
 
                     auto pos = std::array<double, 3>{};
                     double r_x = j + gx;
                     double r_y = i + gy;
                     double r_z = k + gz;
                     pos[0] = R.mdata[0] * r_x + R.mdata[1] * r_y + R.mdata[2] * r_z;
                     pos[1] = R.mdata[3] * r_x + R.mdata[4] * r_y + R.mdata[5] * r_z;
                     pos[2] = R.mdata[6] * r_x + R.mdata[7] * r_y + R.mdata[8] * r_z;
                     
                     double voxel_mV = A3D_ELEM(mV,k,i,j);
                     splattingAtPos(pos, voxel_mV, mP, mV);
                     modg += gx*gx+gy*gy+gz*gz;
                     Ncount++;
                 }
             }
         }
     }
 
     def = sqrt(modg/Ncount);
     totalDeformation = def;
 }

◆ fillVectorTerms()

void ProgForwardZernikeImagesPriors::fillVectorTerms	(	int	l1,
		int	l2,
		Matrix1D< int > &	vL1,
		Matrix1D< int > &	vN,
		Matrix1D< int > &	vL2,
		Matrix1D< int > &	vM
	)

Zernike and SPH coefficients allocation.

Definition at line 937 of file forward_zernike_images_priors.cpp.

 {
     int idx = 0;
     vL1.initZeros(vecSize);
     vN.initZeros(vecSize);
     vL2.initZeros(vecSize);
     vM.initZeros(vecSize);
     for (int h=0; h<=l2; h++) {
         int totalSPH = 2*h+1;
         int aux = std::floor(totalSPH/2);
         for (int l=h; l<=l1; l+=2) {
             for (int m=0; m<totalSPH; m++) {
                 VEC_ELEM(vL1,idx) = l;
                 VEC_ELEM(vN,idx) = h;
                 VEC_ELEM(vL2,idx) = h;
                 VEC_ELEM(vM,idx) = m-aux;
                 idx++;
             }
         }
     }
 }

◆ finishProcessing()

void ProgForwardZernikeImagesPriors::finishProcessing ( )

virtual

Write the final parameters.

Reimplemented from XmippMetadataProgram.

Reimplemented in MpiProgForwardZernikeImagesPriors.

Definition at line 285 of file forward_zernike_images_priors.cpp.

                                                       {
     XmippMetadataProgram::finishProcessing();
     rename(Rerunable::getFileName().c_str(), (fnOutDir + fn_out).c_str());
 }

◆ linearCombinationClnm()

void ProgForwardZernikeImagesPriors::linearCombinationClnm ( )

Definition at line 1106 of file forward_zernike_images_priors.cpp.

 {
     clnm.initZeros(3*vecSize);
     for (int idx=0; idx < 3*vecSize; idx++)
     {
         for (int idc = 0; idc < priors.size(); idc++)
             clnm[idx] += c_priors[idc] * priors[idc][idx];
     }
 }

◆ minimizepos()

void ProgForwardZernikeImagesPriors::minimizepos ( Matrix1D< double > & steps )

Determine the positions to be minimize of a vector containing spherical harmonic coefficients.

Definition at line 929 of file forward_zernike_images_priors.cpp.

 {
     int size = priors.size();
     for (int idx=0; idx<size; idx++) {
         VEC_ELEM(steps,idx) = 1.;
     }   
 }

◆ numCoefficients()

void ProgForwardZernikeImagesPriors::numCoefficients	(	int	l1,
		int	l2,
		int &	vecSize
	)

Length of coefficients vector.

Definition at line 913 of file forward_zernike_images_priors.cpp.

 {
     for (int h=0; h<=l2; h++)
     {
         int numSPH = 2*h+1;
         int count=l1-h+1;
         int numEven=(count>>1)+(count&1 && !(h&1));
         if (h%2 == 0) {
             vecSize += numSPH*numEven;
         }
         else {
             vecSize += numSPH*(l1-h+1-numEven);
         }
     }
 }

◆ optimalPowellOrder()

void ProgForwardZernikeImagesPriors::optimalPowellOrder ( )

Definition at line 1116 of file forward_zernike_images_priors.cpp.

 {
     do_not_init = false;
     std::vector<double> z(priors[0].size(), 0.0);
     priors.push_back(z);
     Matrix1D<double> cost_vec;
     cost_vec.initZeros(priors.size());
     int totalSize = priors.size() + algn_params + ctf_params;
 
     // Initialize some values
     // TODO: Optimize parameters for each image (not sharing)
     // prm->deltaDefocusU[0]=x[idx+6]; prm->deltaDefocusU[1]=x[idx+6]; 
     // prm->deltaDefocusV[0]=x[idx+7]; prm->deltaDefocusV[1]=x[idx+7]; 
     // prm->deltaDefocusAngle[0]=x[idx+8]; prm->deltaDefocusAngle[1]=x[idx+8];
 
     switch (num_images)
     {
     case 2:
         deltaX[0] = 0;
         deltaY[0] = 0;
         deltaRot[0] = 0;
         deltaTilt[0] = 0;
         deltaPsi[0] = 0;
         // prm->deltaDefocusU[0]=x[idx + 11];
         // prm->deltaDefocusV[0]=x[idx + 13];
         // prm->deltaDefocusAngle[0]=x[idx + 15];
 
         deltaX[1] = 0;
         deltaY[1] = 0;
         deltaRot[1] = 0;
         deltaTilt[1] = 0;
         deltaPsi[1] = 0;
         // prm->deltaDefocusU[1]=x[idx + 12];
         // prm->deltaDefocusV[1]=x[idx + 14];
         // prm->deltaDefocusAngle[1]=x[idx + 16];
 
         MAT_ELEM(A1, 0, 2) = old_shiftX[0];
         MAT_ELEM(A1, 1, 2) = old_shiftY[0];
         MAT_ELEM(A1, 0, 0) = 1;
         MAT_ELEM(A1, 0, 1) = 0;
         MAT_ELEM(A1, 1, 0) = 0;
         MAT_ELEM(A1, 1, 1) = 1;
 
         MAT_ELEM(A2, 0, 2) = old_shiftX[1];
         MAT_ELEM(A2, 1, 2) = old_shiftY[1];
         MAT_ELEM(A2, 0, 0) = 1;
         MAT_ELEM(A2, 0, 1) = 0;
         MAT_ELEM(A2, 1, 0) = 0;
         MAT_ELEM(A2, 1, 1) = 1;
         break;
 
     case 3:
         deltaX[0] = 0;
         deltaY[0] = 0;
         deltaRot[0] = 0;
         deltaTilt[0] = 0;
         deltaPsi[0] = 0;
         // prm->deltaDefocusU[0]=x[idx + 16];
         // prm->deltaDefocusV[0]=x[idx + 19];
         // prm->deltaDefocusAngle[0]=x[idx + 22];
 
         deltaX[1] = 0;
         deltaY[1] = 0;
         deltaRot[1] = 0;
         deltaTilt[1] = 0;
         deltaPsi[1] = 0;
         // prm->deltaDefocusU[1]=x[idx + 17];
         // prm->deltaDefocusV[1]=x[idx + 20];
         // prm->deltaDefocusAngle[1]=x[idx + 23];
 
         deltaX[2] = 0;
         deltaY[2] = 0;
         deltaRot[2] = 0;
         deltaTilt[2] = 0;
         deltaPsi[2] = 0;
         // prm->deltaDefocusU[2]=x[idx + 18];
         // prm->deltaDefocusV[2]=x[idx + 21];
         // prm->deltaDefocusAngle[2]=x[idx + 24];
 
         MAT_ELEM(A1, 0, 2) = old_shiftX[0];
         MAT_ELEM(A1, 1, 2) = old_shiftY[0];
         MAT_ELEM(A1, 0, 0) = 1;
         MAT_ELEM(A1, 0, 1) = 0;
         MAT_ELEM(A1, 1, 0) = 0;
         MAT_ELEM(A1, 1, 1) = 1;
 
         MAT_ELEM(A2, 0, 2) = old_shiftX[1];
         MAT_ELEM(A2, 1, 2) = old_shiftY[1];
         MAT_ELEM(A2, 0, 0) = 1;
         MAT_ELEM(A2, 0, 1) = 0;
         MAT_ELEM(A2, 1, 0) = 0;
         MAT_ELEM(A2, 1, 1) = 1;
 
         MAT_ELEM(A3, 0, 2) = old_shiftX[2];
         MAT_ELEM(A3, 1, 2) = old_shiftY[2];
         MAT_ELEM(A3, 0, 0) = 1;
         MAT_ELEM(A3, 0, 1) = 0;
         MAT_ELEM(A3, 1, 0) = 0;
         MAT_ELEM(A3, 1, 1) = 1;
         break;
 
     
     default:
         deltaX[0] = 0;
         deltaY[0] = 0;
         deltaRot[0] = 0;
         deltaTilt[0] = 0;
         deltaPsi[0] = 0;
         deltaDefocusU[0] = 0;
         deltaDefocusV[0] = 0;
         deltaDefocusAngle[0] = 0;
 
         MAT_ELEM(A1, 0, 2) = old_shiftX[0];
         MAT_ELEM(A1, 1, 2) = old_shiftY[0];
         MAT_ELEM(A1, 0, 0) = 1;
         MAT_ELEM(A1, 0, 1) = 0;
         MAT_ELEM(A1, 1, 0) = 0;
         MAT_ELEM(A1, 1, 1) = 1;
         break;
     }
 
     auto lambda_aux = lambda;
     lambda = 0.0;
     for (int idx=0; idx < priors.size(); idx++)
     {
         clnm.initZeros(3*vecSize);
         p.initZeros(totalSize);
         p[idx] = 1.0;
         double *pptr = p.adaptForNumericalRecipes();
         cost_vec[idx] = transformImageSph(pptr);
     }
     lambda = lambda_aux;
 
     std::vector<std::size_t> index_vec;
     for (std::size_t i = 0; i != priors.size(); ++i)
     {
         index_vec.push_back(i);
     }
 
     std::sort(
         index_vec.begin(), index_vec.end(),
         [&](std::size_t a, std::size_t b)
         { return cost_vec[a] < cost_vec[b]; });
 
     auto priors_aux = priors;
     auto prior_deformations_aux = prior_deformations;
     priors.clear();
     prior_deformations.clear();
     for (std::size_t i = 0; i != index_vec.size(); ++i)
     {
         auto v = priors_aux[index_vec[i]];
         auto d = prior_deformations_aux[index_vec[i]];
         bool zeros = std::all_of(v.begin(), v.end(), [](double j) { return j==0.0; });
         if (!zeros)
         {
             priors.push_back(v);
             prior_deformations.push_back(d);
         }
         else if (zeros && i==0)
             do_not_init = true;
     }
 }

◆ preProcess()

void ProgForwardZernikeImagesPriors::preProcess ( )

virtual

Produce side info. An exception is thrown if any of the files is not found

Reimplemented from XmippMetadataProgram.

Definition at line 138 of file forward_zernike_images_priors.cpp.

 {
     V.read(fnVolR);
     V().setXmippOrigin();
     Xdim=XSIZE(V());
     Vdeformed().initZeros(V());
     Vdeformed().setXmippOrigin();
 
     std::string line;
     std::ifstream priorsFile(fnPriors.getString());
     bool first_line = true;
     while (std::getline(priorsFile, line))
     {
         if (first_line)
         {
             std::vector<double> basisParams = string2vector(line);
             L1 = (int)basisParams[0]; L2 = (int)basisParams[1]; RmaxDef = (int)basisParams[2];
             first_line = false;
             for (int idx=3; idx < basisParams.size(); idx++)
                 prior_deformations.push_back(basisParams[idx]);
         }
         else 
         {
             priors.push_back(string2vector(line));
         }
     }
 
     // Check execution mode (single, pair, or triplet)
     if (image_mode > 0)
     {
         num_images = image_mode;
     }
     else{
         num_images = 1; // Single image
         if (getInputMd()->containsLabel(MDL_IMAGE1) && !getInputMd()->containsLabel(MDL_IMAGE2))
         {
             num_images = 2; // Pair
         }
         else if (getInputMd()->containsLabel(MDL_IMAGE1) && getInputMd()->containsLabel(MDL_IMAGE2))
         {
             num_images = 3; // Triplet
         }
     }
 
     // Preallocate vectors (Size depends on image number)
     fnImage.resize(num_images, "");
     I.resize(num_images); Ifiltered.resize(num_images); Ifilteredp.resize(num_images);
     P.resize(num_images);
     old_rot.resize(num_images, 0.); old_tilt.resize(num_images, 0.); old_psi.resize(num_images, 0.);
     deltaRot.resize(num_images, 0.); deltaTilt.resize(num_images, 0.); deltaPsi.resize(num_images, 0.);
     old_shiftX.resize(num_images, 0.); old_shiftY.resize(num_images, 0.);
     deltaX.resize(num_images, 0.); deltaY.resize(num_images, 0.);
     old_defocusU.resize(num_images, 0.); old_defocusV.resize(num_images, 0.); old_defocusAngle.resize(num_images, 0.);
     deltaDefocusU.resize(num_images, 0.); deltaDefocusV.resize(num_images, 0.); deltaDefocusAngle.resize(num_images, 0.);
     currentDefocusU.resize(num_images, 0.); currentDefocusV.resize(num_images, 0.); currentAngle.resize(num_images, 0.);
 
     switch (num_images)
     {
     case 2:
         Ifilteredp[0]().initZeros(Xdim,Xdim); Ifilteredp[1]().initZeros(Xdim,Xdim);
         Ifilteredp[0]().setXmippOrigin(); Ifilteredp[1]().setXmippOrigin();
         P[0]().initZeros(Xdim,Xdim); P[1]().initZeros(Xdim,Xdim);
         break;
     case 3:
         Ifilteredp[0]().initZeros(Xdim,Xdim); Ifilteredp[1]().initZeros(Xdim,Xdim); Ifilteredp[2]().initZeros(Xdim,Xdim);
         Ifilteredp[0]().setXmippOrigin(); Ifilteredp[1]().setXmippOrigin(); Ifilteredp[2]().setXmippOrigin();
         P[0]().initZeros(Xdim,Xdim); P[1]().initZeros(Xdim,Xdim); P[2]().initZeros(Xdim,Xdim);
         break;
     
     default:
         Ifilteredp[0]().initZeros(Xdim,Xdim);
         Ifilteredp[0]().setXmippOrigin();
         P[0]().initZeros(Xdim,Xdim);
         break;
     }
 
     if (RmaxDef<0)
         RmaxDef = Xdim/2;
 
     // Read Reference mask if avalaible (otherwise sphere of radius RmaxDef is used)
     Mask mask;
     mask.type = BINARY_CIRCULAR_MASK;
     mask.mode = INNER_MASK;
     if (fnMaskR != "") {
         Image<double> aux;
         aux.read(fnMaskR);
         typeCast(aux(), V_mask);
         V_mask.setXmippOrigin();
         double Rmax2 = RmaxDef*RmaxDef;
         for (int k=STARTINGZ(V_mask); k<=FINISHINGZ(V_mask); k++) {
             for (int i=STARTINGY(V_mask); i<=FINISHINGY(V_mask); i++) {
                 for (int j=STARTINGX(V_mask); j<=FINISHINGX(V_mask); j++) {
                     double r2 = k*k + i*i + j*j;
                     if (r2>=Rmax2)
                         A3D_ELEM(V_mask,k,i,j) = 0;
                 }
             }
         }
     }
     else {
         mask.R1 = RmaxDef;
         mask.generate_mask(V());
         V_mask = mask.get_binary_mask();
         V_mask.setXmippOrigin();
     }
 
     // Construct mask
     if (Rmax<0)
         Rmax=Xdim/2;
     mask.R1 = Rmax;
     mask.generate_mask(Xdim,Xdim);
     mask2D=mask.get_binary_mask();
 
     // Low pass filter
     filter.FilterBand=LOWPASS;
     filter.w1=Ts/maxResol;
     filter.raised_w=0.02;
 
     // Transformation matrix
     A1.initIdentity(3);
     A2.initIdentity(3);
     A3.initIdentity(3);
 
     // CTF Filter
     FilterCTF1.FilterBand = CTF;
     FilterCTF1.ctf.enable_CTFnoise = false;
     FilterCTF1.ctf.produceSideInfo();
     FilterCTF2.FilterBand = CTF;
     FilterCTF2.ctf.enable_CTFnoise = false;
     FilterCTF2.ctf.produceSideInfo();
     FilterCTF3.FilterBand = CTF;
     FilterCTF3.ctf.enable_CTFnoise = false;
     FilterCTF3.ctf.produceSideInfo();
 
     vecSize = 0;
     numCoefficients(L1,L2,vecSize);
     fillVectorTerms(L1,L2,vL1,vN,vL2,vM);
 
     createWorkFiles();
 
     // Blob
     blob.radius = blob_r;   // Blob radius in voxels
     blob.order  = 2;        // Order of the Bessel function
     blob.alpha  = 3.6;      // Smoothness parameter
 
 }

◆ processImage()

void ProgForwardZernikeImagesPriors::processImage	(	const FileName &	fnImg,
		const FileName &	fnImgOut,
		const MDRow &	rowIn,
		MDRow &	rowOut
	)

virtual

Predict angles and shift. At the input the pose parameters must have an initial guess of the parameters. At the output they have the estimated pose.

Implements XmippMetadataProgram.

Definition at line 642 of file forward_zernike_images_priors.cpp.

 {
     Matrix1D<double> steps;
     // totalSize = 3*num_Z_coeff + num_images * 2 shifts + num_images * 3 angles + num_images * 3 CTF
     algn_params = num_images * 5;
     ctf_params = num_images * 3;
     int totalSize = priors.size() + algn_params + ctf_params;
     p.initZeros(totalSize);
     c_priors.initZeros(totalSize);
     clnm.initZeros(3*vecSize);
 
     flagEnabled=1;
 
     rowIn.getValueOrDefault(MDL_IMAGE,       fnImage[0], "");
     rowIn.getValueOrDefault(MDL_ANGLE_ROT,   old_rot[0], 0.0);
     rowIn.getValueOrDefault(MDL_ANGLE_TILT,  old_tilt[0], 0.0);
     rowIn.getValueOrDefault(MDL_ANGLE_PSI,   old_psi[0], 0.0);
     rowIn.getValueOrDefault(MDL_SHIFT_X,     old_shiftX[0], 0.0);
     rowIn.getValueOrDefault(MDL_SHIFT_Y,     old_shiftY[0], 0.0);
     I[0].read(fnImage[0]); 
     I[0]().setXmippOrigin();
     Ifiltered[0]() = I[0](); 
     filter.applyMaskSpace(Ifiltered[0]());
     
     switch (num_images)
     {
     case 2:
         rowIn.getValueOrDefault(MDL_IMAGE1,      fnImage[1], "");
         rowIn.getValueOrDefault(MDL_ANGLE_ROT2,  old_rot[1], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_TILT2, old_tilt[1], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_PSI2,  old_psi[1], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_X2,    old_shiftX[1], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_Y2,    old_shiftY[1], 0.0);
         I[1].read(fnImage[1]);
         I[1]().setXmippOrigin();
         Ifiltered[1]() = I[1](); 
         filter.applyMaskSpace(Ifiltered[1]());
 
         if (verbose >= 2)
             std::cout << "Processing Pair (" << fnImage[0] << "," << fnImage[1] << ")" << std::endl;
         break;
 
     case 3:
         rowIn.getValueOrDefault(MDL_IMAGE1,      fnImage[1], "");
         rowIn.getValueOrDefault(MDL_ANGLE_ROT2,  old_rot[1], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_TILT2, old_tilt[1], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_PSI2,  old_psi[1], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_X2,    old_shiftX[1], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_Y2,    old_shiftY[1], 0.0);
         I[1].read(fnImage[1]);
         I[1]().setXmippOrigin();
         Ifiltered[1]() = I[1](); 
         filter.applyMaskSpace(Ifiltered[1]());
 
         rowIn.getValueOrDefault(MDL_IMAGE2,      fnImage[2], "");
         rowIn.getValueOrDefault(MDL_ANGLE_ROT3,  old_rot[2], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_TILT3, old_tilt[2], 0.0);
         rowIn.getValueOrDefault(MDL_ANGLE_PSI3,  old_psi[2], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_X3,    old_shiftX[2], 0.0);
         rowIn.getValueOrDefault(MDL_SHIFT_Y3,    old_shiftY[2], 0.0);
         I[2].read(fnImage[2]);
         I[2]().setXmippOrigin();
         Ifiltered[2]() = I[2](); 
         filter.applyMaskSpace(Ifiltered[2]());
 
         if (verbose >= 2)
             std::cout << "Processing Triplet (" << fnImage[0] << "," << fnImage[1] << "," << fnImage[2] << ")" << std::endl;
         break;
     
     default:
         if (verbose >= 2)
             std::cout << "Processing Image (" << fnImage[0] << ")" << std::endl;
         break;
     }
 
     if (rowIn.containsLabel(MDL_FLIP))
         rowIn.getValue(MDL_FLIP,old_flip);
     else
         old_flip = false;
 
     // FIXME: Add defocus per image and make CTF correction available
     if ((rowIn.containsLabel(MDL_CTF_DEFOCUSU) || rowIn.containsLabel(MDL_CTF_MODEL)) && useCTF)
     {
         hasCTF=true;
         FilterCTF1.ctf.readFromMdRow(rowIn);
         FilterCTF1.ctf.Tm = Ts;
         FilterCTF1.ctf.produceSideInfo();
         old_defocusU[0]=FilterCTF1.ctf.DeltafU;
         old_defocusV[0]=FilterCTF1.ctf.DeltafV;
         old_defocusAngle[0]=FilterCTF1.ctf.azimuthal_angle;
     }
     else
         hasCTF=false;
 
     prior_deformation = 0.0;
     optimalPowellOrder();
     p.initZeros(totalSize);
     c_priors.initZeros(totalSize);
     clnm.initZeros(3*vecSize);
     if (!do_not_init)
     {
         p[0] = 1.0;
         c_priors[0] = 1.0;
         clnm = priors[0];
         prior_deformation = prior_deformations[0];
     }
 
     if (verbose >= 2)
     {
         std::cout << std::endl;
         std::cout << "------------------------------ Fiding priors linear combination ----------------------------" << std::endl;
     }
     steps.clear();
     steps.initZeros(totalSize);
 
     // Optimize
     double cost = -1;
     try
     {
         cost = 1e38;
         int iter;
         if (optimizeAlignment)
         {
             int init = steps.size() - algn_params - ctf_params;
             int end = steps.size() - ctf_params;
             for (int i = init; i < end; i++)
                 steps(i) = 1.;
         }
         if (optimizeDefocus)
         {
             int init = steps.size() - ctf_params;
             int end = steps.size();
             for (int i = init; i < end; i++)
                 steps(i) = 1.;
         }
         minimizepos(steps);
         steps_cp = steps;
         powellOptimizer(p, 1, totalSize, &continuousZernikePriorsCost, this, 0.01, cost, iter, steps, verbose >= 2);
         
         if (verbose >= 3)
         {
             showOptimization = true;
             continuousZernikePriorsCost(p.adaptForNumericalRecipes(), this);
             showOptimization = false;
         }
 
         if (cost > 0)
         {
             flagEnabled = -1;
             p.initZeros();
         }
         cost = -cost;
         correlation = cost;
         if (verbose >= 2)
         {
             std::cout << std::endl;
             for (int j = 1; j < 4; j++)
             {
                 switch (j)
                 {
                 case 1:
                     std::cout << "X Coefficients=(";
                     break;
                 case 2:
                     std::cout << "Y Coefficients=(";
                     break;
                 case 3:
                     std::cout << "Z Coefficients=(";
                     break;
                 default:
                     // Default case will be never reached
                     break;
                 }
                 for (int i = (j - 1) * vecSize; i < j * vecSize; i++)
                 {
                     std::cout << clnm(i);
                     if (i < j * vecSize - 1)
                         std::cout << ",";
                 }
                 std::cout << ")" << std::endl;
             }
             std::cout << "Radius=" << RmaxDef << std::endl;
             std::cout << " Dshift=(" << p(totalSize - 5) << "," << p(totalSize - 4) << ") "
                       << "Drot=" << p(totalSize - 3) << " Dtilt=" << p(totalSize - 2)
                       << " Dpsi=" << p(totalSize - 1) << std::endl;
             std::cout << " Total deformation=" << totalDeformation << std::endl;
             std::cout << std::endl;
         }
     }
     catch (XmippError &XE)
     {
         std::cerr << XE.what() << std::endl;
         std::cerr << "Warning: Cannot refine " << fnImg << std::endl;
         flagEnabled = -1;
     }
 
     //AJ NEW
     writeImageParameters(rowOut);
     //END AJ
 
 }

◆ readParams()

void ProgForwardZernikeImagesPriors::readParams ( )

virtual

Read argument from command line.

Reimplemented from XmippMetadataProgram.

Definition at line 47 of file forward_zernike_images_priors.cpp.

 {
     XmippMetadataProgram::readParams();
     fnVolR = getParam("--ref");
     fnMaskR = getParam("--mask");
     fnPriors = getParam("--priors");
     fnOutDir = getParam("--odir");
     maxShift = getDoubleParam("--max_shift");
     maxAngularChange = getDoubleParam("--max_angular_change");
     maxResol = getDoubleParam("--max_resolution");
     Ts = getDoubleParam("--sampling");
     Rmax = getIntParam("--Rmax");
     RmaxDef = getIntParam("--RDef");
     optimizeAlignment = checkParam("--optimizeAlignment");
     optimizeDefocus = checkParam("--optimizeDefocus");
     phaseFlipped = checkParam("--phaseFlipped");
     useCTF = checkParam("--useCTF");
     L1 = getIntParam("--l1");
     L2 = getIntParam("--l2");
     loop_step = getIntParam("--step");
     image_mode = getIntParam("--image_mode");
     resume = checkParam("--resume");
     lambda = getDoubleParam("--regularization");
     Rerunable::setFileName(fnOutDir + "/sphDone.xmd");
     blob_r = getDoubleParam("--blobr");
     keep_input_columns = true;
 }

◆ show()

void ProgForwardZernikeImagesPriors::show ( )

Show.

Definition at line 76 of file forward_zernike_images_priors.cpp.

 {
     if (!verbose)
         return;
     XmippMetadataProgram::show();
     std::cout
     << "Output directory:    " << fnOutDir           << std::endl
     << "Reference volume:    " << fnVolR             << std::endl
     << "Reference mask:      " << fnMaskR            << std::endl
     << "Max. Shift:          " << maxShift           << std::endl
     << "Max. Angular Change: " << maxAngularChange   << std::endl
     << "Max. Resolution:     " << maxResol           << std::endl
     << "Sampling:            " << Ts                 << std::endl
     << "Max. Radius:         " << Rmax               << std::endl
     << "Max. Radius Deform.  " << RmaxDef            << std::endl
     << "Zernike Degree:      " << L1                 << std::endl
     << "SH Degree:           " << L2                 << std::endl
     << "Step:                " << loop_step          << std::endl
     << "Correct CTF:         " << useCTF             << std::endl
     << "Optimize alignment:  " << optimizeAlignment  << std::endl
     << "Optimize defocus:    " << optimizeDefocus    << std::endl
     << "Regularization:      " << lambda             << std::endl
     << "Phase flipped:       " << phaseFlipped       << std::endl
     << "Blob radius:         " << blob_r             << std::endl
     << "Image mode:          " << image_mode         << std::endl
     ;
 }

◆ splattingAtPos()

void ProgForwardZernikeImagesPriors::splattingAtPos	(	std::array< double, 3 >	r,
		double	weight,
		MultidimArray< double > &	mP,
		const MultidimArray< double > &	mV
	)

Definition at line 1076 of file forward_zernike_images_priors.cpp.

                                                                                                                                                     {
     // Find the part of the volume that must be updated
     double x_pos = r[0];
     double y_pos = r[1];
     double z_pos = r[2];
     int i0 = XMIPP_MAX(FLOOR(y_pos - blob_r), STARTINGY(mV));
     int iF = XMIPP_MIN(CEIL(y_pos + blob_r), FINISHINGY(mV));
     int j0 = XMIPP_MAX(FLOOR(x_pos - blob_r), STARTINGX(mV));
     int jF = XMIPP_MIN(CEIL(x_pos + blob_r), FINISHINGX(mV));
     for (int i = i0; i <= iF; i++)
     {
         double y_val = bspline1(i - y_pos);
         for (int j = j0; j <= jF; j++)
         {
             double x_val = bspline1(j - x_pos);
             A2D_ELEM(mP, i, j) += weight * x_val * y_val;
         }
     }
 }

◆ string2vector()

std::vector< double > ProgForwardZernikeImagesPriors::string2vector ( std::string const & s ) const

Definition at line 1096 of file forward_zernike_images_priors.cpp.

 {
     std::stringstream iss(s);
     double number;
     std::vector<double> v;
     while (iss >> number)
         v.push_back(number);
     return v;
 }

◆ transformImageSph()

double ProgForwardZernikeImagesPriors::transformImageSph ( double * pc_priors )

Definition at line 290 of file forward_zernike_images_priors.cpp.

 {
     const MultidimArray<double> &mV=V();
     FOR_ALL_ELEMENTS_IN_MATRIX1D(c_priors)
         VEC_ELEM(c_priors,i)=pc_priors[i+1];
 
     linearCombinationClnm();
 
     double deformation=0.0;
     totalDeformation=0.0;
 
     P[0]().initZeros(Xdim,Xdim);
     P[0]().setXmippOrigin();
     double currentRot=old_rot[0] + deltaRot[0];
     double currentTilt=old_tilt[0] + deltaTilt[0];
     double currentPsi=old_psi[0] + deltaPsi[0];
     deformVol(P[0](), mV, deformation, currentRot, currentTilt, currentPsi);
 
     double cost=0.0;
     const MultidimArray<int> &mMask2D=mask2D;
     double corr2 = 0.0;
     double corr3 = 0.0;
 
     switch (num_images)
     {
     case 2:
     {
         P[1]().initZeros(Xdim,Xdim);
         P[1]().setXmippOrigin();
         currentRot = old_rot[1] + deltaRot[1];
         currentTilt = old_tilt[1] + deltaTilt[1];
         currentPsi = old_psi[1] + deltaPsi[1];
         deformVol(P[1](), mV, deformation, currentRot, currentTilt, currentPsi);
 
         if (old_flip)
         {
             MAT_ELEM(A1, 0, 0) *= -1;
             MAT_ELEM(A1, 0, 1) *= -1;
             MAT_ELEM(A1, 0, 2) *= -1;
             MAT_ELEM(A2, 0, 0) *= -1;
             MAT_ELEM(A2, 0, 1) *= -1;
             MAT_ELEM(A2, 0, 2) *= -1;
         }
         applyGeometry(xmipp_transformation::LINEAR, Ifilteredp[0](), Ifiltered[0](), A1, 
                       xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, 0.);
         applyGeometry(xmipp_transformation::LINEAR, Ifilteredp[1](), Ifiltered[1](), A2, 
                       xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, 0.);
         // filter.applyMaskSpace(P[1]());
         const MultidimArray<double> mP2 = P[1]();
         MultidimArray<double> &mI2filteredp = Ifilteredp[1]();
         corr2 = correlationIndex(mI2filteredp, mP2, &mMask2D);
     }
         break;
 
     case 3:
     {
         P[1]().initZeros(Xdim,Xdim);
         P[1]().setXmippOrigin();
         currentRot = old_rot[1] + deltaRot[1];
         currentTilt = old_tilt[1] + deltaTilt[1];
         currentPsi = old_psi[1] + deltaPsi[1];
         deformVol(P[1](), mV, deformation, currentRot, currentTilt, currentPsi);
 
         P[2]().initZeros(Xdim,Xdim);
         P[2]().setXmippOrigin();
         currentRot = old_rot[2] + deltaRot[2];
         currentTilt = old_tilt[2] + deltaTilt[2];
         currentPsi = old_psi[2] + deltaPsi[2];
         deformVol(P[2](), mV, deformation, currentRot, currentTilt, currentPsi);
 
         if (old_flip)
         {
             MAT_ELEM(A1, 0, 0) *= -1;
             MAT_ELEM(A1, 0, 1) *= -1;
             MAT_ELEM(A1, 0, 2) *= -1;
             MAT_ELEM(A2, 0, 0) *= -1;
             MAT_ELEM(A2, 0, 1) *= -1;
             MAT_ELEM(A2, 0, 2) *= -1;
             MAT_ELEM(A3, 0, 0) *= -1;
             MAT_ELEM(A3, 0, 1) *= -1;
             MAT_ELEM(A3, 0, 2) *= -1;
         }
         applyGeometry(xmipp_transformation::LINEAR, Ifilteredp[0](), Ifiltered[0](), A1, 
                       xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, 0.);
         applyGeometry(xmipp_transformation::LINEAR, Ifilteredp[1](), Ifiltered[1](), A2, 
                       xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, 0.);
         applyGeometry(xmipp_transformation::LINEAR, Ifilteredp[2](), Ifiltered[2](), A3, 
                       xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, 0.);
         // filter.applyMaskSpace(P[1]());
         // filter.applyMaskSpace(P[2]());
         const MultidimArray<double> mP2 = P[1]();
         const MultidimArray<double> mP3 = P[2]();
         MultidimArray<double> &mI2filteredp = Ifilteredp[1]();
         MultidimArray<double> &mI3filteredp = Ifilteredp[2]();
         corr2 = correlationIndex(mI2filteredp, mP2, &mMask2D);
         corr3 = correlationIndex(mI3filteredp, mP3, &mMask2D);
     }
         break;
     
     default:
         if (old_flip)
         {
             MAT_ELEM(A1, 0, 0) *= -1;
             MAT_ELEM(A1, 0, 1) *= -1;
             MAT_ELEM(A1, 0, 2) *= -1;
         }
         applyGeometry(xmipp_transformation::LINEAR,Ifilteredp[0](),Ifiltered[0](),A1,
                       xmipp_transformation::IS_NOT_INV,xmipp_transformation::DONT_WRAP,0.);
         break;
     }
 
     if (hasCTF)
     {
         double defocusU=old_defocusU[0]+deltaDefocusU[0];
         double defocusV=old_defocusV[0]+deltaDefocusV[0];
         double angle=old_defocusAngle[0]+deltaDefocusAngle[0];
         if (defocusU!=currentDefocusU[0] || defocusV!=currentDefocusV[0] || angle!=currentAngle[0]) {
             updateCTFImage(defocusU,defocusV,angle);
         }
         FilterCTF1.generateMask(P[0]());
         if (phaseFlipped)
             FilterCTF1.correctPhase();
         FilterCTF1.applyMaskSpace(P[0]());
     }
     filter.applyMaskSpace(P[0]());
 
 
     const MultidimArray<double> mP1=P[0]();
     MultidimArray<double> &mI1filteredp=Ifilteredp[0]();
     double corr1=correlationIndex(mI1filteredp,mP1,&mMask2D);
 
     switch (num_images)
     {
     case 2:
         cost=-(corr1+corr2+corr3) / 2.0;
         break;
     case 3:
         cost=-(corr1+corr2+corr3) / 3.0;
         break;  
     default:
         cost=-(corr1+corr2+corr3);
         break;
     }
 
 #ifdef DEBUG
     std::cout << "A=" << A << std::endl;
     Image<double> save;
     save()=P();
     save.write("PPPtheo.xmp");
     save()=Ifilteredp();
     save.write("PPPfilteredp.xmp");
     save()=Ifiltered();
     save.write("PPPfiltered.xmp");
     // Vdeformed.write("PPPVdeformed.vol");
     std::cout << "Cost=" << cost << " deformation=" << deformation << std::endl;
     std::cout << "Press any key" << std::endl;
     char c; std::cin >> c;
 #endif
 
    if (showOptimization)
    {
         std::cout << "A1=" << A1 << std::endl;
         Image<double> save;
         save()=P[0]();
         save.write("PPPtheo1.xmp");
         save()=Ifilteredp[0]();
         save.write("PPPfilteredp1.xmp");
         save()=Ifiltered[0]();
         save.write("PPPfiltered1.xmp");
 
         switch (num_images)
         {
             case 2:
             {
                 std::cout << "A2=" << A2 << std::endl;
                 save()=P[1]();
                 save.write("PPPtheo2.xmp");
                 save()=Ifilteredp[1]();
                 save.write("PPPfilteredp2.xmp");
                 save()=Ifiltered[1]();
                 save.write("PPPfiltered2.xmp");
             }
                 break;
 
             case 3:
             {
                 std::cout << "A2=" << A2 << std::endl;
                 save()=P[1]();
                 save.write("PPPtheo2.xmp");
                 save()=Ifilteredp[1]();
                 save.write("PPPfilteredp2.xmp");
                 save()=Ifiltered[1]();
                 save.write("PPPfiltered2.xmp");
 
                 std::cout << "A3=" << A3 << std::endl;
                 save()=P[2]();
                 save.write("PPPtheo3.xmp");
                 save()=Ifilteredp[2]();
                 save.write("PPPfilteredp3.xmp");
                 save()=Ifiltered[2]();
                 save.write("PPPfiltered3.xmp");
             }
                 break;
             
             default:
                 break;
         }
         Vdeformed.write("PPPVdeformed.vol");
         std::cout << "Deformation=" << totalDeformation << std::endl;
         std::cout << "Press any key" << std::endl;
         char c; std::cin >> c;
     }
 
     double bound = 1.0;
     double sum = 0.0;
     for (int i=0; i < priors.size(); i++) {
         sum += c_priors[i];
         if (c_priors[i] < 0.0)
         {
             bound = 0.0;
             break;
         }
     }
 
     if (sum > 1.0 && bound == 1.0)
         bound = 0.0;
 
     if (showOptimization)
         std::cout << cost << " " << deformation << std::endl;
     return bound * cost + lambda * abs(deformation - prior_deformation);
 }

◆ updateCTFImage()

void ProgForwardZernikeImagesPriors::updateCTFImage	(	double	defocusU,
		double	defocusV,
		double	angle
	)

Definition at line 960 of file forward_zernike_images_priors.cpp.

 {
     FilterCTF1.ctf.K=1; // get pure CTF with no envelope
     currentDefocusU[0]=FilterCTF1.ctf.DeltafU=defocusU;
     currentDefocusV[0]=FilterCTF1.ctf.DeltafV=defocusV;
     currentAngle[0]=FilterCTF1.ctf.azimuthal_angle=angle;
     FilterCTF1.ctf.produceSideInfo();
 }

◆ weightsInterpolation3D()

Matrix1D< double > ProgForwardZernikeImagesPriors::weightsInterpolation3D	(	double	x,
		double	y,
		double	z
	)

Definition at line 1045 of file forward_zernike_images_priors.cpp.

                                                                                                     {
     Matrix1D<double> w;
     w.initZeros(8);
 
     int x0 = FLOOR(x);
     double fx0 = x - x0;
     int x1 = x0 + 1;
     double fx1 = x1 - x;
 
     int y0 = FLOOR(y);
     double fy0 = y - y0;
     int y1 = y0 + 1;
     double fy1 = y1 - y;
 
     int z0 = FLOOR(z);
     double fz0 = z - z0;
     int z1 = z0 + 1;
     double fz1 = z1 - z;
 
     VEC_ELEM(w,0) = fx1 * fy1 * fz1;  // w000 (x0,y0,z0)
     VEC_ELEM(w,1) = fx1 * fy1 * fz0;  // w001 (x0,y0,z1)
     VEC_ELEM(w,2) = fx1 * fy0 * fz1;  // w010 (x0,y1,z0)
     VEC_ELEM(w,3) = fx1 * fy0 * fz0;  // w011 (x0,y1,z1)
     VEC_ELEM(w,4) = fx0 * fy1 * fz1;  // w100 (x1,y0,z0)
     VEC_ELEM(w,5) = fx0 * fy1 * fz0;  // w101 (x1,y0,z1)
     VEC_ELEM(w,6) = fx0 * fy0 * fz1;  // w110 (x1,y1,z0)
     VEC_ELEM(w,7) = fx0 * fy0 * fz0;  // w111 (x1,y1,z1)
 
     return w;
 }

◆ writeImageParameters()

void ProgForwardZernikeImagesPriors::writeImageParameters ( MDRow & row )

virtual

Write the parameters found for one image

Definition at line 844 of file forward_zernike_images_priors.cpp.

                                                                     {
     int pos = priors.size();
     if (flagEnabled==1) {
         row.setValue(MDL_ENABLED, 1);
     }
     else {
         row.setValue(MDL_ENABLED, -1);
     }
 
     switch (num_images)
     {
     case 2:
         row.setValue(MDL_ANGLE_ROT,   old_rot[0]+p(pos+4));
         row.setValue(MDL_ANGLE_ROT2,  old_rot[1]+p(pos+5));
         row.setValue(MDL_ANGLE_TILT,  old_tilt[0]+p(pos+6));
         row.setValue(MDL_ANGLE_TILT2, old_tilt[1]+p(pos+7));
         row.setValue(MDL_ANGLE_PSI,   old_psi[0]+p(pos+8));
         row.setValue(MDL_ANGLE_PSI2,  old_psi[1]+p(pos+9));
         row.setValue(MDL_SHIFT_X,     old_shiftX[0]+p(pos));
         row.setValue(MDL_SHIFT_X2,    old_shiftX[1]+p(pos+1));
         row.setValue(MDL_SHIFT_Y,     old_shiftY[0]+p(pos+2));
         row.setValue(MDL_SHIFT_Y2,    old_shiftY[1]+p(pos+3));
         break;
 
     case 3:
         row.setValue(MDL_ANGLE_ROT,   old_rot[0]+p(pos+6));
         row.setValue(MDL_ANGLE_ROT2,  old_rot[1]+p(pos+7));
         row.setValue(MDL_ANGLE_ROT3,  old_rot[2]+p(pos+8));
         row.setValue(MDL_ANGLE_TILT,  old_tilt[0]+p(pos+9));
         row.setValue(MDL_ANGLE_TILT2, old_tilt[1]+p(pos+10));
         row.setValue(MDL_ANGLE_TILT3, old_tilt[2]+p(pos+11));
         row.setValue(MDL_ANGLE_PSI,   old_psi[0]+p(pos+12));
         row.setValue(MDL_ANGLE_PSI2,  old_psi[1]+p(pos+13));
         row.setValue(MDL_ANGLE_PSI3,  old_psi[2]+p(pos+14));
         row.setValue(MDL_SHIFT_X,     old_shiftX[0]+p(pos));
         row.setValue(MDL_SHIFT_X2,    old_shiftX[1]+p(pos+1));
         row.setValue(MDL_SHIFT_X3,    old_shiftX[2]+p(pos+2));
         row.setValue(MDL_SHIFT_Y,     old_shiftY[0]+p(pos+3));
         row.setValue(MDL_SHIFT_Y2,    old_shiftY[1]+p(pos+4));
         row.setValue(MDL_SHIFT_Y3,    old_shiftY[2]+p(pos+5));
         break;
     
     default:
         row.setValue(MDL_ANGLE_ROT,   old_rot[0]+p(pos+2));
         row.setValue(MDL_ANGLE_TILT,  old_tilt[0]+p(pos+3));
         row.setValue(MDL_ANGLE_PSI,   old_psi[0]+p(pos+4));
         row.setValue(MDL_SHIFT_X,     old_shiftX[0]+p(pos));
         row.setValue(MDL_SHIFT_Y,     old_shiftY[0]+p(pos+1));
         break;
     }
 
     row.setValue(MDL_SPH_DEFORMATION, totalDeformation);
     std::vector<double> vectortemp;
     size_t end_clnm = VEC_XSIZE(clnm);
     for (int j = 0; j < end_clnm; j++) {
         vectortemp.push_back(clnm(j));
     }
     row.setValue(MDL_SPH_COEFFICIENTS, vectortemp);
     row.setValue(MDL_COST, correlation);
 }

Member Data Documentation

◆ A1

Matrix2D<double> ProgForwardZernikeImagesPriors::A1

Definition at line 114 of file forward_zernike_images_priors.h.

◆ A2

Matrix2D<double> ProgForwardZernikeImagesPriors::A2

Definition at line 114 of file forward_zernike_images_priors.h.

◆ A3

Matrix2D<double> ProgForwardZernikeImagesPriors::A3

Definition at line 114 of file forward_zernike_images_priors.h.

◆ algn_params

int ProgForwardZernikeImagesPriors::algn_params

Definition at line 85 of file forward_zernike_images_priors.h.

◆ blob

struct blobtype ProgForwardZernikeImagesPriors::blob

Definition at line 149 of file forward_zernike_images_priors.h.

◆ blob_r

double ProgForwardZernikeImagesPriors::blob_r

Definition at line 150 of file forward_zernike_images_priors.h.

◆ c_priors

Matrix1D<double> ProgForwardZernikeImagesPriors::c_priors

Definition at line 134 of file forward_zernike_images_priors.h.

◆ clnm

Matrix1D<double> ProgForwardZernikeImagesPriors::clnm

Definition at line 136 of file forward_zernike_images_priors.h.

◆ correlation

double ProgForwardZernikeImagesPriors::correlation

Definition at line 145 of file forward_zernike_images_priors.h.

◆ ctf_params

int ProgForwardZernikeImagesPriors::ctf_params

Definition at line 87 of file forward_zernike_images_priors.h.

◆ currentAngle

std::vector<double> ProgForwardZernikeImagesPriors::currentAngle

Definition at line 126 of file forward_zernike_images_priors.h.

◆ currentDefocusU

std::vector<double> ProgForwardZernikeImagesPriors::currentDefocusU

Definition at line 126 of file forward_zernike_images_priors.h.

◆ currentDefocusV

std::vector<double> ProgForwardZernikeImagesPriors::currentDefocusV

Definition at line 126 of file forward_zernike_images_priors.h.

◆ deltaDefocusAngle

std::vector<double> ProgForwardZernikeImagesPriors::deltaDefocusAngle

Definition at line 124 of file forward_zernike_images_priors.h.

◆ deltaDefocusU

std::vector<double> ProgForwardZernikeImagesPriors::deltaDefocusU

Definition at line 124 of file forward_zernike_images_priors.h.

◆ deltaDefocusV

std::vector<double> ProgForwardZernikeImagesPriors::deltaDefocusV

Definition at line 124 of file forward_zernike_images_priors.h.

◆ deltaPsi

std::vector<double> ProgForwardZernikeImagesPriors::deltaPsi

Definition at line 116 of file forward_zernike_images_priors.h.

◆ deltaRot

std::vector<double> ProgForwardZernikeImagesPriors::deltaRot

Definition at line 116 of file forward_zernike_images_priors.h.

◆ deltaTilt

std::vector<double> ProgForwardZernikeImagesPriors::deltaTilt

Definition at line 116 of file forward_zernike_images_priors.h.

◆ deltaX

std::vector<double> ProgForwardZernikeImagesPriors::deltaX

Definition at line 118 of file forward_zernike_images_priors.h.

◆ deltaY

std::vector<double> ProgForwardZernikeImagesPriors::deltaY

Definition at line 118 of file forward_zernike_images_priors.h.

◆ do_not_init

bool ProgForwardZernikeImagesPriors::do_not_init

Definition at line 151 of file forward_zernike_images_priors.h.

◆ filter

FourierFilter ProgForwardZernikeImagesPriors::filter

Definition at line 112 of file forward_zernike_images_priors.h.

◆ FilterCTF1

FourierFilter ProgForwardZernikeImagesPriors::FilterCTF1

Definition at line 128 of file forward_zernike_images_priors.h.

◆ FilterCTF2

FourierFilter ProgForwardZernikeImagesPriors::FilterCTF2

Definition at line 129 of file forward_zernike_images_priors.h.

◆ FilterCTF3

FourierFilter ProgForwardZernikeImagesPriors::FilterCTF3

Definition at line 130 of file forward_zernike_images_priors.h.

◆ flagEnabled

int ProgForwardZernikeImagesPriors::flagEnabled

Definition at line 89 of file forward_zernike_images_priors.h.

◆ fnImage

std::vector<FileName> ProgForwardZernikeImagesPriors::fnImage

Definition at line 103 of file forward_zernike_images_priors.h.

◆ fnMaskR

FileName ProgForwardZernikeImagesPriors::fnMaskR

Filename of the reference volume mask

Definition at line 49 of file forward_zernike_images_priors.h.

◆ fnOutDir

FileName ProgForwardZernikeImagesPriors::fnOutDir

Output directory.

Definition at line 53 of file forward_zernike_images_priors.h.

◆ fnPriors

FileName ProgForwardZernikeImagesPriors::fnPriors

List of priors (deformation coefficients)

Definition at line 51 of file forward_zernike_images_priors.h.

◆ fnVolR

FileName ProgForwardZernikeImagesPriors::fnVolR

Filename of the reference volume

Definition at line 47 of file forward_zernike_images_priors.h.

◆ hasCTF

bool ProgForwardZernikeImagesPriors::hasCTF

Definition at line 122 of file forward_zernike_images_priors.h.

◆ I

std::vector<Image<double> > ProgForwardZernikeImagesPriors::I

Definition at line 106 of file forward_zernike_images_priors.h.

◆ Ifiltered

std::vector<Image<double> > ProgForwardZernikeImagesPriors::Ifiltered

Definition at line 107 of file forward_zernike_images_priors.h.

◆ Ifilteredp

std::vector<Image<double> > ProgForwardZernikeImagesPriors::Ifilteredp

Definition at line 108 of file forward_zernike_images_priors.h.

◆ ignoreCTF

bool ProgForwardZernikeImagesPriors::ignoreCTF

Definition at line 73 of file forward_zernike_images_priors.h.

◆ image_mode

int ProgForwardZernikeImagesPriors::image_mode

Definition at line 90 of file forward_zernike_images_priors.h.

◆ L1

int ProgForwardZernikeImagesPriors::L1

Degrees of Zernike polynomials and spherical harmonics

Definition at line 55 of file forward_zernike_images_priors.h.

◆ L2

int ProgForwardZernikeImagesPriors::L2

Definition at line 55 of file forward_zernike_images_priors.h.

◆ lambda

double ProgForwardZernikeImagesPriors::lambda

Definition at line 79 of file forward_zernike_images_priors.h.

◆ loop_step

int ProgForwardZernikeImagesPriors::loop_step

Definition at line 147 of file forward_zernike_images_priors.h.

◆ mask2D

MultidimArray<int> ProgForwardZernikeImagesPriors::mask2D

Definition at line 97 of file forward_zernike_images_priors.h.

◆ maxAngularChange

double ProgForwardZernikeImagesPriors::maxAngularChange

Maximum angular change allowed

Definition at line 61 of file forward_zernike_images_priors.h.

◆ maxResol

double ProgForwardZernikeImagesPriors::maxResol

Maximum frequency (A)

Definition at line 63 of file forward_zernike_images_priors.h.

◆ maxShift

double ProgForwardZernikeImagesPriors::maxShift

Maximum shift allowed

Definition at line 59 of file forward_zernike_images_priors.h.

◆ num_images

int ProgForwardZernikeImagesPriors::num_images

Definition at line 83 of file forward_zernike_images_priors.h.

◆ old_defocusAngle

std::vector<double> ProgForwardZernikeImagesPriors::old_defocusAngle

Definition at line 124 of file forward_zernike_images_priors.h.

◆ old_defocusU

std::vector<double> ProgForwardZernikeImagesPriors::old_defocusU

Definition at line 124 of file forward_zernike_images_priors.h.

◆ old_defocusV

std::vector<double> ProgForwardZernikeImagesPriors::old_defocusV

Definition at line 124 of file forward_zernike_images_priors.h.

◆ old_flip

bool ProgForwardZernikeImagesPriors::old_flip

Definition at line 120 of file forward_zernike_images_priors.h.

◆ old_psi

std::vector<double> ProgForwardZernikeImagesPriors::old_psi

Definition at line 116 of file forward_zernike_images_priors.h.

◆ old_rot

std::vector<double> ProgForwardZernikeImagesPriors::old_rot

Definition at line 116 of file forward_zernike_images_priors.h.

◆ old_shiftX

std::vector<double> ProgForwardZernikeImagesPriors::old_shiftX

Definition at line 118 of file forward_zernike_images_priors.h.

◆ old_shiftY

std::vector<double> ProgForwardZernikeImagesPriors::old_shiftY

Definition at line 118 of file forward_zernike_images_priors.h.

◆ old_tilt

std::vector<double> ProgForwardZernikeImagesPriors::old_tilt

Definition at line 116 of file forward_zernike_images_priors.h.

◆ optimizeAlignment

bool ProgForwardZernikeImagesPriors::optimizeAlignment

Definition at line 69 of file forward_zernike_images_priors.h.

◆ optimizeDefocus

bool ProgForwardZernikeImagesPriors::optimizeDefocus

Definition at line 71 of file forward_zernike_images_priors.h.

◆ optimizeRadius

bool ProgForwardZernikeImagesPriors::optimizeRadius

Definition at line 75 of file forward_zernike_images_priors.h.

◆ p

Matrix1D<double> ProgForwardZernikeImagesPriors::p

Definition at line 88 of file forward_zernike_images_priors.h.

◆ P

std::vector<Image<double> > ProgForwardZernikeImagesPriors::P

Definition at line 110 of file forward_zernike_images_priors.h.

◆ phaseFlipped

bool ProgForwardZernikeImagesPriors::phaseFlipped

Definition at line 77 of file forward_zernike_images_priors.h.

◆ prior_deformation

double ProgForwardZernikeImagesPriors::prior_deformation

Definition at line 140 of file forward_zernike_images_priors.h.

◆ prior_deformations

std::vector<double> ProgForwardZernikeImagesPriors::prior_deformations

Definition at line 141 of file forward_zernike_images_priors.h.

◆ priors

std::vector<std::vector<double> > ProgForwardZernikeImagesPriors::priors

Vector containing the priors

Definition at line 99 of file forward_zernike_images_priors.h.

◆ resume

bool ProgForwardZernikeImagesPriors::resume

Resume computations

Definition at line 95 of file forward_zernike_images_priors.h.

◆ Rmax

int ProgForwardZernikeImagesPriors::Rmax

Maximum radius

Definition at line 67 of file forward_zernike_images_priors.h.

◆ RmaxDef

int ProgForwardZernikeImagesPriors::RmaxDef

Definition at line 81 of file forward_zernike_images_priors.h.

◆ showOptimization

bool ProgForwardZernikeImagesPriors::showOptimization

Definition at line 143 of file forward_zernike_images_priors.h.

◆ steps_cp

Matrix1D<double> ProgForwardZernikeImagesPriors::steps_cp

Definition at line 138 of file forward_zernike_images_priors.h.

◆ totalDeformation

double ProgForwardZernikeImagesPriors::totalDeformation

Definition at line 140 of file forward_zernike_images_priors.h.

◆ Ts

double ProgForwardZernikeImagesPriors::Ts

Sampling rate

Definition at line 65 of file forward_zernike_images_priors.h.

◆ useCTF

bool ProgForwardZernikeImagesPriors::useCTF

Definition at line 91 of file forward_zernike_images_priors.h.

◆ V

Image<double> ProgForwardZernikeImagesPriors::V

Definition at line 105 of file forward_zernike_images_priors.h.

◆ V_mask

MultidimArray<int> ProgForwardZernikeImagesPriors::V_mask

Definition at line 97 of file forward_zernike_images_priors.h.

◆ Vdeformed

Image<double> ProgForwardZernikeImagesPriors::Vdeformed

Definition at line 105 of file forward_zernike_images_priors.h.

◆ vecSize

int ProgForwardZernikeImagesPriors::vecSize

Definition at line 132 of file forward_zernike_images_priors.h.

◆ vL1

Matrix1D<int> ProgForwardZernikeImagesPriors::vL1

Zernike and SPH coefficients vectors

Definition at line 57 of file forward_zernike_images_priors.h.

◆ vL2

Matrix1D<int> ProgForwardZernikeImagesPriors::vL2

Definition at line 57 of file forward_zernike_images_priors.h.

◆ vM

Matrix1D<int> ProgForwardZernikeImagesPriors::vM

Definition at line 57 of file forward_zernike_images_priors.h.

◆ vN

Matrix1D<int> ProgForwardZernikeImagesPriors::vN

Definition at line 57 of file forward_zernike_images_priors.h.

◆ Xdim

size_t ProgForwardZernikeImagesPriors::Xdim

Definition at line 101 of file forward_zernike_images_priors.h.

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

xmipp/libraries/reconstruction/forward_zernike_images_priors.h
xmipp/libraries/reconstruction/forward_zernike_images_priors.cpp

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Direction

Constructor & Destructor Documentation

◆ ProgForwardZernikeImagesPriors()

◆ ~ProgForwardZernikeImagesPriors()

Member Function Documentation

◆ bspline1()

◆ checkPoint()

◆ createWorkFiles()

◆ defineParams()

◆ deformVol()

◆ fillVectorTerms()

◆ finishProcessing()

◆ linearCombinationClnm()

◆ minimizepos()

◆ numCoefficients()

◆ optimalPowellOrder()

◆ preProcess()

◆ processImage()

◆ readParams()

◆ show()

◆ splattingAtPos()

◆ string2vector()

◆ transformImageSph()

◆ updateCTFImage()

◆ weightsInterpolation3D()

◆ writeImageParameters()

Member Data Documentation

◆ A1

◆ A2

◆ A3

◆ algn_params

◆ blob

◆ blob_r

◆ c_priors

◆ clnm

◆ correlation

◆ ctf_params

◆ currentAngle

◆ currentDefocusU

◆ currentDefocusV

◆ deltaDefocusAngle

◆ deltaDefocusU

◆ deltaDefocusV

◆ deltaPsi

◆ deltaRot

◆ deltaTilt

◆ deltaX

◆ deltaY

◆ do_not_init

◆ filter

◆ FilterCTF1

◆ FilterCTF2

◆ FilterCTF3

◆ flagEnabled

◆ fnImage

◆ fnMaskR

◆ fnOutDir

◆ fnPriors

◆ fnVolR

◆ hasCTF

◆ I

◆ Ifiltered

◆ Ifilteredp

◆ ignoreCTF

◆ image_mode

◆ L1

◆ L2

◆ lambda

◆ loop_step

◆ mask2D

◆ maxAngularChange

◆ maxResol

◆ maxShift