#include <ctf_sort_psds.h>

Inheritance diagram for ProgPSDSort:

Collaboration diagram for ProgPSDSort:

Public Member Functions
	ProgPSDSort ()
	Downsampling factor used for the PSDs. More...

void	defineLabelParam ()

void	readParams ()

void	defineParams ()

void	show ()

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

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	checkPoint ()
	For very long programs, it may be needed to write checkpoints. 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
double	filter_w1
	Bandpass filter low frequency (in Fourier space, max 0.5) More...

double	filter_w2
	Bandpass filter high frequency (in Fourier space, max 0.5) More...

double	decay_width
	Decay width (raised cosine) More...

double	mask_w1
	Lower frequency for the mask (in Fourier space, max 0.5) More...

double	mask_w2
	Higher frequency for the mask (in Fourier space, max 0.5) More...

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

Additional Inherited Members
Protected Member Functions inherited from XmippMetadataProgram
virtual void	initComments ()

virtual void	preProcess ()

virtual void	postProcess ()

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

void	show () const override

virtual void	startProcessing ()

virtual void	finishProcessing ()

virtual void	writeOutput ()

virtual void	showProgress ()

Protected Member Functions inherited from XmippProgram
void	defineCommons ()

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

Parameter class for the project program

Definition at line 61 of file ctf_sort_psds.h.

Constructor & Destructor Documentation

◆ ProgPSDSort()

ProgPSDSort::ProgPSDSort ( )

Downsampling factor used for the PSDs.

Empty constructor

Definition at line 34 of file ctf_sort_psds.cpp.

 {
     produces_an_output=true;
     produces_a_metadata=true;
     keep_input_columns=true;
 }

Member Function Documentation

◆ defineLabelParam()

void ProgPSDSort::defineLabelParam ( )

virtual

Use micrographs for iterating in the metadata

Reimplemented from XmippMetadataProgram.

Definition at line 41 of file ctf_sort_psds.cpp.

 {
     addParamsLine(" [--label+ <image_label=micrograph>]   : Label to be used to read/write images.");
 }

◆ defineParams()

void ProgPSDSort::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgPSDSort >.

Definition at line 59 of file ctf_sort_psds.cpp.

 {
     XmippMetadataProgram::defineParams();
     addUsageLine("Evaluate the CTFs and PSDs of a set of micrographs.");
     addUsageLine("This process is strongly coupled to the output produced by the preprocessing micrographs step of the Xmipp protocols. ");
     addUsageLine("For each input PSD, the program writes its enhanced version since it is used in the computation of some of the criteria.");
     addUsageLine("+The different criteria for evaluating the PSDs are:");
     addUsageLine("+ ");
     addUsageLine("+$ *Damping*: this is the envelope value at the border of the PSD. Micrographs ");
     addUsageLine("+with a high envelope value at border are either wrongly estimated strongly undersampled.");
     addUsageLine("+ ");
     addUsageLine("+$ *First zero average*: this is average in Angstroms of the first zero. ");
     addUsageLine("+Normally, this value should be between 4x and 10x the sampling rate in Angstroms.");
     addUsageLine("+ ");
     addUsageLine("+$ *Maximum frequency*: this is the resolution (in Angstroms) at which the envelope drops below 1% of the maximum envelope");
     addUsageLine("+ ");
     addUsageLine("+$ *First zero disagreement*: if the CTF has been estimated by two different methods ");
     addUsageLine("+(normally Xmipp and Ctffind), then this criterion measures the average disagreement ");
     addUsageLine("+in Angstroms between the first zero in the two estimates. Low disagreements are ");
     addUsageLine("+indicative of correct fit.");
     addUsageLine("+ ");
     addUsageLine("+$ *First zero ratio*: this measures the astigmatism of the CTF by computing the ratio ");
     addUsageLine("+between the largest and smallest axes of the first zero ellipse. Ratios close to 1 ");
     addUsageLine("+indicate no astigmatism.");
     addUsageLine("+ ");
     addUsageLine("+$ *Ratio between the standard deviation at 1st zero and 1st minimum*: the variance in the experimental PSD along the");
     addUsageLine("+first zero and the first CTF minimum should be approximately equal (ratio=1).");
     addUsageLine("+ ");
     addUsageLine("+$ *CTF margin*: ratio between the average difference in the experimental PSD between the 1st Thon");
     addUsageLine("+ring and its previous zero, and the variance of the experimental PSD along the first zero");
     addUsageLine("+first zero and the first CTF minimum should be approximately equal (ratio=1).");
     addUsageLine("+ ");
     addUsageLine("+$ *Fitting score*: the CTF is computed by fitting a theoretical model to the experimentally observed PSD. ");
     addUsageLine("+This criterion is the fitting score. Smaller scores correspond to better fits.");
     addUsageLine("+ ");
     addUsageLine("+$ *Fitting correlation between zeros 1 and 3*: the region between the first and third zeroes ");
     addUsageLine("+is particularly important since it is where the Thon rings are most visible. ");
     addUsageLine("+This criterion reports the correlation between the experimental and theoretical PSDs ");
     addUsageLine("+within this region. High correlations indicate good fits.");
     addUsageLine("+ ");
     addUsageLine("+$ *Non-astigmatic validity*: if we consider the CTF cosine part in the direction U and V ");
     addUsageLine("+and add both as if they were waves, this criterion shows the frequency (in Angstroms) at which ");
     addUsageLine("+both waves would interfere completely destructively. Beyond this frequency, it cannot be assumed that ");
     addUsageLine("+a non-astigmatic CTF correction can manage an astigmatic CTF");
     addUsageLine("+ ");
     addUsageLine("+$ *PSD correlation at 90 degrees*: The PSD of non-astigmatic micrographs correlate well ");
     addUsageLine("+with itself after rotating the micrograph 90 degrees. This is so because non-astigmatic ");
     addUsageLine("+PSDs are circularly symmetrical, while astigmatic micrographs are elliptically symmetrical.");
     addUsageLine("+High correlation when rotating 90 degrees is an indicator of non-astigmatism.");
     addUsageLine("+This criterion is computed on the enhanced PSD. See [[ctf_enhance_psd_v3][ctf_enhance_psd]].");
     addUsageLine("+ ");
     addUsageLine("+$ *PSD radial integral*: this criterion reports the integral of the radially symmetrized PSD.");
     addUsageLine("+This criterion can highlight differences among the background noises of micrographs. ");
     addUsageLine("+This criterion is computed on the enhanced PSD. See [[ctf_enhance_psd_v3][ctf_enhance_psd]].");
     addUsageLine("+ ");
     addUsageLine("+$ *PSD variance*: the PSD is estimated by averaging different PSD local estimates in small regions of the micrograph. ");
     addUsageLine("+This criterion measures the variance of the different PSD local estimates. Untilted micrographs ");
     addUsageLine("+have equal defoci all over the micrograph, and therefore, the variance is due only to noise. ");
     addUsageLine("+However, tilted micrographs have an increased PSD variance since different regions of the micrograph ");
     addUsageLine("+have different defoci. Low variance of the PSD are indicative of non-tilted micrographs");
     addUsageLine("+ ");
     addUsageLine("+$ *PSD Principal Component 1 Variance*: when considering the local PSDs previously defined as vectors ");
     addUsageLine("+in a multidimensional space, we can compute the variance of their projection onto the first principal component axis. ");
     addUsageLine("+Low variance of this projection is indicative of a uniformity of local PSDs, i.e., this is another measure ");
     addUsageLine("+of the presence of tilt in the micrograph.");
     addUsageLine("+ ");
     addUsageLine("+$ *PSD !PCA Runs test*: when computing the projections onto the first principal component, as discussed in the previous criterion, ");
     addUsageLine("+one might expect that the sign of the projection is random for untilted micrographs. Micrographs with a marked ");
     addUsageLine("+non-random pattern of projections are indicative of tilted micrographs. The larger the value of this criterion, the less random the pattern is.");
     addParamsLine("==+ Enhancement filter parameters");
     addParamsLine("  [-f1 <freq_low=0.02>]      : Low freq. for band pass filtration, max 0.5");
     addParamsLine("  [-f2 <freq_high=0.2>]      : High freq. for band pass filtration, max 0.5");
     addParamsLine("  [-decay <freq_decay=0.02>] : Decay for the transition bands");
     addParamsLine("  [-m1 <mfreq_low=0.01>]     : Low freq. for mask, max 0.5");
     addParamsLine("  [-m2 <mfreq_high=0.45>]    : High freq. for mask, max 0.5");
     // COSS addParamsLine("  [--downsampling <K=1>]     : Downsampling factor used");
 }

◆ processImage()

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

virtual

Process micrograph

Implements XmippMetadataProgram.

Definition at line 153 of file ctf_sort_psds.cpp.

 {
     CTFDescription CTF1, CTF2;
     PSDEvaluation evaluation;
     FileName fnMicrograph, fnPSD, fnCTF, fnCTF2;
 
     evaluation.ctf_envelope_ssnr = fn_in.getDir()+"envelope.xmd";
 
     int enabled;
     rowIn.getValue(MDL_ENABLED,enabled);
     rowIn.getValue(MDL_MICROGRAPH, fnMicrograph);
     rowIn.getValue(MDL_PSD,fnPSD);
     if (enabled==-1 || fnPSD == "NA")
     {
         rowOut.setValue(MDL_ENABLED,-1);
         return;
     }
 
     if (rowIn.containsLabel(MDL_CTF_MODEL))
     {
       rowIn.getValue(MDL_CTF_MODEL, fnCTF);
       if (!fnCTF.exists())
       {
           rowOut.setValue(MDL_ENABLED,-1);
           return;
       }
       CTF1.read(fnCTF);
     }
     else
         CTF1.readFromMdRow(rowIn);
 
     FileName fnRoot = fnMicrograph.withoutExtension();
 
     CTF1.produceSideInfo();
     evaluation.defocusU=CTF1.DeltafU;
     evaluation.defocusV=CTF1.DeltafV;
 
 
     if (rowIn.containsLabel(MDL_CTF_MODEL2))
         rowIn.getValue(MDL_CTF_MODEL2,fnCTF2);
 
     if (!fnCTF2.empty() && fnCTF2 != "NA")
     {
         CTF2.read(fnCTF2);
         CTF2.produceSideInfo();
     }
 
     // Evaluate beating due to astigmatism
     /* The argument of the cosine part of the CTF is:                     wu=cos(K1*deltafu*u.^2+K2*u.^4)
      * If there is no astigmatism, then in the V direction we would have  wv=cos(K1*deltafv*u.^2+K2*u.^4)
      * and we should have (wu+wv)/2 = wu.
      * If there is astigmatism, the sum (wu+wv)/2 will depart from the behavior of wu
      * http://en.wikipedia.org/wiki/Beat_%28acoustics%29
      * calling argu and argv the argument of the two waves, we have
      *
      * (wu+wv)/2=cos((argu+argv)/2)cos((argu-argv)/2)
      *
      * The term cos((argu-argv)/2) acts as an envelope which may even vanish. Let's analyze this envelope
      * cos(0.5*(K1*deltafu*u.^2+K2*u.^4-K1*deltafv*u.^2+K2*u.^4))=cos(0.5*K1*abs(deltafu-deltafv)*u^2)
      *
      * When this envelope is 0, the interference between the two waves is totally destructive (we cannot apply a
      * non-astigmatic correction to an astigmatic CTF). This happens for
      *
      * 0.5*K1*abs(deltafu-deltafv)*u_0^2=pi/2 ---> u_0=sqrt(PI/(K1*abs(deltafu-deltafv)))
      *
      * This is the expression of critBeating
      */
     evaluation.beating=1.0/sqrt(PI/(CTF1.K1*abs(CTF1.DeltafU-CTF1.DeltafV)));
 
     // Read input PSD data
     Image<double> PSD;
     PSD.read(fnPSD);
 
     // Enhance the PSD
     ProgCTFEnhancePSD enhancePSD;
     enhancePSD.filter_w1 = filter_w1;
     enhancePSD.filter_w2 = filter_w2;
     enhancePSD.decay_width = decay_width;
     enhancePSD.mask_w1 = mask_w1;
     enhancePSD.mask_w2 = mask_w2;
     enhancePSD.applyFilter(PSD());
 
     // Evaluate the radial integral
     PSD().setXmippOrigin();
     Matrix1D< int > center_of_rot(2);
     MultidimArray< double > radial_mean;
     MultidimArray<int> radial_count;
     radialAverage(PSD(),center_of_rot,radial_mean,radial_count);
     radial_mean.selfABS();
     radial_mean/=radial_mean.computeMax();
     evaluation.PSDradialIntegral=radial_mean.sum();
 
     // Rotate 90 degrees and compute correlation
     Image<double> PSDrotated;
     rotate(xmipp_transformation::LINEAR,PSDrotated(),PSD(),90);
     evaluation.PSDcorrelation90=correlationIndex(PSD(), PSDrotated());
 
     // Get the fitting score and other quality criteria computed by ctf_estimate_from_micrograph
     MetaDataVec MDctf1;
     MDctf1.read(fnCTF);
     size_t objId1 = MDctf1.firstRowId();
 
 #define GET_CTF_CRITERION(labelll,xxx) \
     if (rowIn.containsLabel(labelll)) \
         rowIn.getValue(labelll,xxx); \
     else if (MDctf1.containsLabel(labelll)) \
         MDctf1.getValue(labelll,xxx,objId1); \
     else \
         xxx=0;
     GET_CTF_CRITERION(MDL_CTF_CRIT_FITTINGSCORE,evaluation.fittingScore);
     GET_CTF_CRITERION(MDL_CTF_CRIT_FITTINGCORR13,evaluation.fittingCorr13);
     GET_CTF_CRITERION(MDL_CTF_CRIT_PSDVARIANCE,evaluation.PSDVariance);
     GET_CTF_CRITERION(MDL_CTF_CRIT_PSDPCA1VARIANCE,evaluation.PSDPC1Variance);
     GET_CTF_CRITERION(MDL_CTF_CRIT_PSDPCARUNSTEST,evaluation.PSDPCRunsTest);
 
     // Explore the CTF
     Matrix1D<double> u(2), freqZero1(2), freqZero2(2), freqMin1(2), pixelZero1(2), pixelMin1(2);
     double wmax=0.5/CTF1.Tm;
     double maxModuleZero=0, minModuleZero=1e38;
     double N=0;
     evaluation.maxDampingAtBorder=0;
     evaluation.firstZeroDisagreement=-1;
     evaluation.firstZeroAvg=0;
     double firstZeroAvgPSD=0;
     double firstZeroStddevPSD=0;
     double firstMinAvgPSD=0;
     double firstMinStddevPSD=0;
     double firstZeroMinAvgPSD=0;
     double firstZeroMinStddevPSD=0;
     evaluation.maxFreq=1000;
 
     CTF1.precomputeValues(0.0,0.0);
     double idamping0=1.0/CTF1.getValueDampingAt();
     double f2pixel=CTF1.Tm*XSIZE(PSD()); // COSS *downsampling
 
     if (rowIn.containsLabel(MDL_CTF_DOWNSAMPLE_PERFORMED))
     {
         double aux;
         rowIn.getValue(MDL_CTF_DOWNSAMPLE_PERFORMED,aux);
         f2pixel*=aux;
     }
 
     MetaDataVec mdEnvelope;
     Matrix1D< double > envelope(100);
     envelope.initZeros();
     double Nalpha = 180;
     for (double alpha=0; alpha<=PI; alpha+=PI/Nalpha, N++)
     {
         VECTOR_R2(u,cos(alpha),sin(alpha));
 
         // Get the zero in the direction of u
         CTF1.lookFor(1, u, freqZero1, 0);
         double moduleZero=1.0/freqZero1.module();
         maxModuleZero=XMIPP_MAX(maxModuleZero,moduleZero);
         minModuleZero=XMIPP_MIN(minModuleZero,moduleZero);
         evaluation.firstZeroAvg+=moduleZero;
 
         // Get the first minimum (it is at higher frequency than the zero)
         CTF1.lookFor(1, u, freqMin1, -1);
         pixelZero1=freqZero1*f2pixel;
         pixelMin1=freqMin1*f2pixel;
         double psdZero=PSD().interpolatedElement2D(XX(pixelZero1),YY(pixelZero1),0.0);
         double psdMin=PSD().interpolatedElement2D(XX(pixelMin1),YY(pixelMin1),0.0);
         firstMinAvgPSD+=psdMin;
         firstMinStddevPSD+=psdMin*psdMin;
         firstZeroAvgPSD+=psdZero;
         firstZeroStddevPSD+=psdZero*psdZero;
         double zeroMinDiff=psdMin-psdZero;
         firstZeroMinAvgPSD+=zeroMinDiff;
         firstZeroMinStddevPSD+=zeroMinDiff*zeroMinDiff;
 
         // Evaluate damping
         double wx=wmax*XX(u);
         double wy=wmax*YY(u);
         CTF1.precomputeValues(wx,wy);
         double damping=CTF1.getValueDampingAt();
         damping=damping*damping;
         evaluation.maxDampingAtBorder=XMIPP_MAX(evaluation.maxDampingAtBorder,damping);
 
         int idx = 0;
         for (double w=0; w<wmax; w+=wmax/99.0)
         {
             wx=w*XX(u);
             wy=w*YY(u);
             CTF1.precomputeValues(wx,wy);
             double normalizedDamping=fabs(CTF1.getValueDampingAt()*idamping0);
             if (normalizedDamping>0.1)
                 evaluation.maxFreq=std::min(evaluation.maxFreq,1.0/w);
 
             VEC_ELEM(envelope,idx) += double(fabs(CTF1.getValueDampingAt()));
             idx++;
         }
 
         if (fnCTF2!="") {
             CTF2.lookFor(1, u, freqZero2, 0);
             double module2=1.0/freqZero2.module();
             double diff=ABS(moduleZero-module2);
             evaluation.firstZeroDisagreement=XMIPP_MAX(evaluation.firstZeroDisagreement,diff);
         }
     }
 
     int idx=0;
     for (double w=0; w<wmax; w+=wmax/99.0)
     {
         size_t objId2 = mdEnvelope.addObject();
         mdEnvelope.setValue(MDL_RESOLUTION_FREQ,w,objId2);
         mdEnvelope.setValue(MDL_CTF_ENVELOPE,VEC_ELEM(envelope,idx)/Nalpha,objId2);
         idx++;
     }
     evaluation.firstZeroAvg/=N;
     evaluation.firstZeroRatio=maxModuleZero/minModuleZero;
     firstZeroAvgPSD/=N;
     firstZeroStddevPSD=sqrt(fabs(firstZeroStddevPSD/N-firstZeroAvgPSD*firstZeroAvgPSD));
     firstMinAvgPSD/=N;
     firstMinStddevPSD=sqrt(fabs(firstMinStddevPSD/N-firstMinAvgPSD*firstMinAvgPSD));
     firstZeroMinAvgPSD/=N;
     firstZeroMinStddevPSD=sqrt(fabs(firstZeroMinStddevPSD/N-firstZeroMinAvgPSD*firstZeroMinAvgPSD));
 
     evaluation.firstMinimumStddev_ZeroStddev=1000;
     evaluation.firstMinimumDiffStddev_ZeroStddev=1000;
     if (firstZeroStddevPSD>1e-6)
     {
         evaluation.firstMinimumStddev_ZeroStddev=firstMinStddevPSD/firstZeroStddevPSD;
         evaluation.firstMinimumDiffStddev_ZeroStddev=firstZeroMinAvgPSD/firstZeroStddevPSD;
     }
 
     // Evaluate micrograph normality
     ImageGeneric M;
     M.readMapped(fnMicrograph);
     double avg, stddev, minval, maxval;
     M().computeStats(avg, stddev, minval, maxval);
     Histogram1D hist;
     compute_hist(M(), hist, minval, maxval, 400);
     hist += 1;
     hist /= hist.sum();
 
     Histogram1D histGaussian;
     histGaussian.initZeros(hist);
     histGaussian.hmin=hist.hmin;
     histGaussian.hmax=hist.hmax;
     histGaussian.step_size=hist.step_size;
     histGaussian.istep_size=hist.istep_size;
     FOR_ALL_ELEMENTS_IN_ARRAY1D(histGaussian) {
         double x;
         hist.index2val(i, x);
         A1D_ELEM(histGaussian,i) = gaussian1D(x, stddev, avg);
     }
     evaluation.histogramNormality=0.5*(KLDistance(hist,histGaussian)+
                                        KLDistance(histGaussian,hist));
 
     // Write criteria
     rowOut.setValue(MDL_CTF_DEFOCUSU,evaluation.defocusU);
     rowOut.setValue(MDL_CTF_DEFOCUSV,evaluation.defocusV);
     rowOut.setValue(MDL_CTF_CRIT_FIRSTZEROAVG,evaluation.firstZeroAvg);
     rowOut.setValue(MDL_CTF_CRIT_MAXFREQ,evaluation.maxFreq);
     rowOut.setValue(MDL_CTF_CRIT_DAMPING,evaluation.maxDampingAtBorder);
     if (evaluation.firstZeroDisagreement>0)
         rowOut.setValue(MDL_CTF_CRIT_FIRSTZERODISAGREEMENT,evaluation.firstZeroDisagreement);
     rowOut.setValue(MDL_CTF_CRIT_FIRSTZERORATIO,evaluation.firstZeroRatio);
     rowOut.setValue(MDL_CTF_ENVELOPE_PLOT,evaluation.ctf_envelope_ssnr);
     rowOut.setValue(MDL_CTF_CRIT_FIRSTMINIMUM_FIRSTZERO_RATIO,evaluation.firstMinimumStddev_ZeroStddev);
     rowOut.setValue(MDL_CTF_CRIT_FIRSTMINIMUM_FIRSTZERO_DIFF_RATIO,evaluation.firstMinimumDiffStddev_ZeroStddev);
     rowOut.setValue(MDL_CTF_CRIT_FITTINGSCORE,evaluation.fittingScore);
     rowOut.setValue(MDL_CTF_CRIT_FITTINGCORR13,evaluation.fittingCorr13);
     rowOut.setValue(MDL_CTF_CRIT_NONASTIGMATICVALIDITY,evaluation.beating);
     rowOut.setValue(MDL_CTF_CRIT_PSDCORRELATION90,evaluation.PSDcorrelation90);
     rowOut.setValue(MDL_CTF_CRIT_PSDRADIALINTEGRAL,evaluation.PSDradialIntegral);
     rowOut.setValue(MDL_CTF_CRIT_PSDVARIANCE,evaluation.PSDVariance);
     rowOut.setValue(MDL_CTF_CRIT_PSDPCA1VARIANCE,evaluation.PSDPC1Variance);
     rowOut.setValue(MDL_CTF_CRIT_PSDPCARUNSTEST,evaluation.PSDPCRunsTest);
     rowOut.setValue(MDL_CTF_CRIT_NORMALITY, evaluation.histogramNormality);
 
 
     //mdEnvelope.write(evaluation.ctf_envelope_ssnr,MD_OVERWRITE);
     mdEnvelope.write(evaluation.ctf_envelope_ssnr,MD_OVERWRITE);
     //std::cout << mdEnvelope << std::endl;
 
 }

◆ readParams()

void ProgPSDSort::readParams ( )

virtual

Read from a command line.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgPSDSort >.

Definition at line 47 of file ctf_sort_psds.cpp.

 {
     XmippMetadataProgram::readParams();
     filter_w1 = getDoubleParam("-f1");
     filter_w2 = getDoubleParam("-f2");
     decay_width = getDoubleParam("-decay");
     mask_w1 = getDoubleParam("-m1");
     mask_w2 = getDoubleParam("-m2");
     // COSS downsampling = getDoubleParam("--downsampling");
 }

◆ show()

void ProgPSDSort::show ( )

Show parameters.

Definition at line 138 of file ctf_sort_psds.cpp.

 {
     if (verbose==0)
         return;
     XmippMetadataProgram::show();
     std::cout
     << "Filter w1:    " << filter_w1 << std::endl
     << "Filter w2:    " << filter_w2 << std::endl
     << "Filter decay: " << decay_width << std::endl
     << "Mask w1:      " << mask_w1 << std::endl
     << "Mask w2:      " << mask_w2 << std::endl ;
     // COSS << "Downsampling: " << downsampling << std::endl;
 }

Member Data Documentation

◆ decay_width

double ProgPSDSort::decay_width

Decay width (raised cosine)

Definition at line 71 of file ctf_sort_psds.h.

◆ filter_w1

double ProgPSDSort::filter_w1

Bandpass filter low frequency (in Fourier space, max 0.5)

Definition at line 65 of file ctf_sort_psds.h.

◆ filter_w2

double ProgPSDSort::filter_w2

Bandpass filter high frequency (in Fourier space, max 0.5)

Definition at line 68 of file ctf_sort_psds.h.

◆ mask_w1

double ProgPSDSort::mask_w1

Lower frequency for the mask (in Fourier space, max 0.5)

Definition at line 74 of file ctf_sort_psds.h.

◆ mask_w2

double ProgPSDSort::mask_w2

Higher frequency for the mask (in Fourier space, max 0.5)

Definition at line 77 of file ctf_sort_psds.h.

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

xmipp/libraries/reconstruction/ctf_sort_psds.h
xmipp/libraries/reconstruction/ctf_sort_psds.cpp

Public Member Functions

Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ProgPSDSort()

Member Function Documentation

◆ defineLabelParam()

◆ defineParams()

◆ processImage()

◆ readParams()

◆ show()

Member Data Documentation

◆ decay_width

◆ filter_w1

◆ filter_w2

◆ mask_w1

◆ mask_w2