Collaboration diagram for CTF Phase flip in 2D particles:

Classes
class	ProgCorrectPhaseFlip2D

class	ProgCorrectWiener2D

Functions
void	ProgCorrectPhaseFlip2D::readParams ()

void	ProgCorrectPhaseFlip2D::defineParams ()

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

void	ProgCorrectWiener2D::readParams ()

void	ProgCorrectWiener2D::defineParams ()

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

void	ProgCorrectWiener2D::generateWienerFilter (MultidimArray< double > &Mwien, CTFDescription &ctf)

void	ProgCorrectWiener2D::postProcess ()

void	ProgVolumeCorrectBfactor::make_guinier_plot (MultidimArray< std::complex< double > > &m1, std::vector< fit_point2D > &guinier)

void	ProgVolumeCorrectBfactor::apply_bfactor (MultidimArray< std::complex< double > > &FT1, double bfactor)

void	ProgVolumeCorrectBfactor::apply_allpoints (MultidimArray< std::complex< double > > &FT1, std::vector< fit_point2D > &guinier_diff)

void	ProgVolumeCorrectBfactor::get_snr_weights (std::vector< double > &snr)

void	ProgVolumeCorrectBfactor::apply_snr_weights (MultidimArray< std::complex< double > > &FT1, std::vector< double > &snr)

void	ProgVolumeCorrectBfactor::write_guinierfile (const FileName &fn_guinier, std::vector< fit_point2D > &guinierin, std::vector< fit_point2D > &guinierweighted, std::vector< fit_point2D > &guiniernew, double intercept, std::vector< fit_point2D > &guinierref)

Variables
double	ProgCorrectPhaseFlip2D::sampling_rate
	Sampling rate. More...

Image< double >	ProgCorrectPhaseFlip2D::img

CTFDescription	ProgCorrectPhaseFlip2D::ctf

size_t	ProgCorrectPhaseFlip2D::Ydim

size_t	ProgCorrectPhaseFlip2D::Xdim

FourierTransformer	ProgCorrectPhaseFlip2D::transformer

Wiener2D	ProgCorrectWiener2D::WF

bool	ProgCorrectWiener2D::phase_flipped

double	ProgCorrectWiener2D::pad

bool	ProgCorrectWiener2D::isIsotropic

bool	ProgCorrectWiener2D::correct_envelope

double	ProgCorrectWiener2D::wiener_constant
	Wiener filter constant. More...

double	ProgCorrectWiener2D::sampling_rate
	Sampling rate. More...

Image< double >	ProgCorrectWiener2D::img

CTFDescription	ProgCorrectWiener2D::ctf

size_t	ProgCorrectWiener2D::Ydim

size_t	ProgCorrectWiener2D::Xdim

MultidimArray< double >	ProgCorrectWiener2D::Mwien

MultidimArray< std::complex< double > >	ProgCorrectWiener2D::Faux

FourierTransformer	ProgCorrectWiener2D::transformer

Detailed Description

Function Documentation

◆ apply_allpoints()

void ProgVolumeCorrectBfactor::apply_allpoints	(	MultidimArray< std::complex< double > > &	FT1,
		std::vector< fit_point2D > &	guinier_diff
	)

Apply B-factor

This will adjust the power spectrum according to the difference Guinier

Definition at line 300 of file volume_correct_bfactor.cpp.

 {
     Matrix1D<double> f(3);
     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(FT1)
     {
         FFT_IDX2DIGFREQ(j,xsize,XX(f));
         FFT_IDX2DIGFREQ(i,YSIZE(FT1),YY(f));
         FFT_IDX2DIGFREQ(k,ZSIZE(FT1),ZZ(f));
         double R=f.module();
         if (R>0.5)
             continue;
         size_t idx=lround(R*xsize);
         if (idx < guinier_diff.size() && guinier_diff[idx].w > 0.)
         {
             dAkij(FT1, k, i, j) *= exp( -guinier_diff[idx].y );
         }
     }
 }

◆ apply_bfactor()

void ProgVolumeCorrectBfactor::apply_bfactor	(	MultidimArray< std::complex< double > > &	FT1,
		double	bfactor
	)

Apply B-factor

This will apply the following operation to the FT1: exp (- bfactor / 4 * d *d)

Definition at line 282 of file volume_correct_bfactor.cpp.

 {
     Matrix1D<double> f(3);
     double isampling_rate=1.0/sampling_rate;
     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(FT1)
     {
         FFT_IDX2DIGFREQ(j,xsize,XX(f));
         FFT_IDX2DIGFREQ(i,YSIZE(FT1),YY(f));
         FFT_IDX2DIGFREQ(k,ZSIZE(FT1),ZZ(f));
         double R = f.module() * isampling_rate;
         if (1./R >= apply_maxres)
         {
             dAkij(FT1, k, i, j) *= exp( -0.25* bfactor  * R * R);
         }
     }
 }

◆ apply_snr_weights()

void ProgVolumeCorrectBfactor::apply_snr_weights	(	MultidimArray< std::complex< double > > &	FT1,
		std::vector< double > &	snr
	)

Apply SNR weights to Fourier Transform of a volume

Definition at line 263 of file volume_correct_bfactor.cpp.

 {
 
     Matrix1D<double> f(3);
     FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(FT1)
     {
         FFT_IDX2DIGFREQ(j,xsize,XX(f));
         FFT_IDX2DIGFREQ(i,YSIZE(FT1),YY(f));
         FFT_IDX2DIGFREQ(k,ZSIZE(FT1),ZZ(f));
         double R = f.module();
         if (sampling_rate / R >= apply_maxres)
         {
             int idx=ROUND(R*xsize);
             dAkij(FT1, k, i, j) *= snr[idx];
         }
     }
 }

◆ defineParams() [1/2]

void ProgCorrectPhaseFlip2D::defineParams ( )

virtual

Function in which the param of each Program are defined.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgCorrectPhaseFlip2D >.

Definition at line 36 of file ctf_correct_phase.cpp.

 {
     addUsageLine("Perform CTF correction to 2D projection images with estimated ctfs using a phase flip filter.");
     each_image_produces_an_output = true;
     XmippMetadataProgram::defineParams();
     addKeywords("correct CTF by phase flipping");
     addParamsLine("   [--sampling_rate <float=1.0>]     : Sampling rate of the input particles");
 }

◆ defineParams() [2/2]

void ProgCorrectWiener2D::defineParams ( )

virtual

Function in which the param of each Program are defined.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgCorrectWiener2D >.

Definition at line 42 of file ctf_correct_wiener2d.cpp.

 {
     addUsageLine("Perform CTF correction to 2D projection images with estimated ctfs using a Wiener filter.");
     each_image_produces_an_output = true;
     XmippMetadataProgram::defineParams();
     addKeywords("correct CTF by Wiener filtering");
     addParamsLine("   [--phase_flipped]       : Is the data already phase-flipped?");
     addParamsLine("   [--isIsotropic]         : Must be considered the defocus isotropic?");
     addParamsLine("   [--sampling_rate <float=1.0>]     : Sampling rate of the input particles");
     addParamsLine("   [--wc <float=-1>]       : Wiener-filter constant (if < 0: use FREALIGN default)");
     addParamsLine("   [--pad <factor=2.> ]    : Padding factor for Wiener correction");
     addParamsLine("   [--correct_envelope]     : Correct the CTF envelope");
 }

◆ generateWienerFilter()

void ProgCorrectWiener2D::generateWienerFilter	(	MultidimArray< double > &	Mwien,
		CTFDescription &	ctf
	)

◆ get_snr_weights()

void ProgVolumeCorrectBfactor::get_snr_weights ( std::vector< double > & snr )

Read FSC file and convert to signal-to-noise weights

Definition at line 243 of file volume_correct_bfactor.cpp.

 {
 
     MetaDataVec md;
     md.read(fn_fsc);
 
     double fsc;
     int line_no = 0;
 
     snr.clear();
 
     for (size_t objId : md.ids())
     {
         md.getValue(MDL_RESOLUTION_FRC, fsc, objId);
         double mysnr = XMIPP_MAX( (2*fsc) / (1+fsc), 0.);
         snr.push_back( sqrt(mysnr) );
     }
 }

◆ make_guinier_plot()

void ProgVolumeCorrectBfactor::make_guinier_plot	(	MultidimArray< std::complex< double > > &	m1,
		std::vector< fit_point2D > &	guinier
	)

Make Guinier plot (logarithm of spherically averaged amplitudes versus resolution in 1/A^2)

Definition at line 146 of file volume_correct_bfactor.cpp.

 {
     MultidimArray< int >  radial_count(xsize);
     MultidimArray<double> lnF(xsize);
     Matrix1D<double>      f(3);
     fit_point2D      onepoint;
 
     lnF.initZeros();
     for (size_t k=0; k<ZSIZE(FT1); k++)
     {
         FFT_IDX2DIGFREQ(k,ZSIZE(FT1),ZZ(f));
         double z2=ZZ(f)*ZZ(f);
         for (size_t i=0; i<YSIZE(FT1); i++)
         {
             FFT_IDX2DIGFREQ(i,YSIZE(FT1),YY(f));
             double y2z2=z2+YY(f)*YY(f);
             for (size_t j=0; j<XSIZE(FT1); j++)
             {
                 FFT_IDX2DIGFREQ(j,xsize,XX(f));
                 double R2=y2z2+XX(f)*XX(f);
                 if (R2>0.25)
                     continue;
                 double R=sqrt(R2);
                 int idx=ROUND(R*xsize);
                 A1D_ELEM(lnF,idx) += abs(dAkij(FT1, k, i, j));
                 ++A1D_ELEM(radial_count,idx);
             }
         }
     }
 
     guinier.clear();
     for (size_t i = 0; i < XSIZE(radial_count); i++)
     {
         double res = (xsize * sampling_rate)/(double)i;
         if (res >= apply_maxres)
         {
             onepoint.x = 1. / (res * res);
             if (lnF(i)>0.)
             {
                 onepoint.y = log ( lnF(i) / radial_count(i) );
                 if (res <= fit_minres && res >= fit_maxres)
                 {
                     onepoint.w = 1.;
                 }
                 else
                 {
                     onepoint.w = 0.;
                 }
             }
             else
             {
                 onepoint.y = 0.;
                 onepoint.w = 0.;
             }
             guinier.push_back(onepoint);
         }
     }
 }

◆ postProcess()

void ProgCorrectWiener2D::postProcess ( )

virtual

Reimplemented from XmippMetadataProgram.

Definition at line 57 of file ctf_correct_wiener2d.cpp.

 {
     MetaData &ptrMdOut = getOutputMd();
 
     ptrMdOut.removeLabel(MDL_CTF_DEFOCUSA);
     ptrMdOut.removeLabel(MDL_CTF_DEFOCUSU);
     ptrMdOut.removeLabel(MDL_CTF_DEFOCUS_ANGLE);
     ptrMdOut.removeLabel(MDL_CTF_DEFOCUSV);
     ptrMdOut.removeLabel(MDL_CTF_BG_BASELINE);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_ANGLE);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_CU);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_CV);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_K);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_SIGMAU);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN2_SIGMAV);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_ANGLE);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_CU);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_CV);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_K);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_SIGMAU);
     ptrMdOut.removeLabel(MDL_CTF_BG_GAUSSIAN_SIGMAV);
     ptrMdOut.removeLabel(MDL_CTF_BG_SQRT_ANGLE);
     ptrMdOut.removeLabel(MDL_CTF_BG_SQRT_K);
     ptrMdOut.removeLabel(MDL_CTF_BG_SQRT_U);
     ptrMdOut.removeLabel(MDL_CTF_BG_SQRT_V);
     ptrMdOut.removeLabel(MDL_CTF_CA);
     ptrMdOut.removeLabel(MDL_CTF_CONVERGENCE_CONE);
     ptrMdOut.removeLabel(MDL_CTF_ENERGY_LOSS);
     ptrMdOut.removeLabel(MDL_CTF_ENVELOPE);
     ptrMdOut.removeLabel(MDL_CTF_LENS_STABILITY);
     ptrMdOut.removeLabel(MDL_CTF_TRANSVERSAL_DISPLACEMENT);
     ptrMdOut.removeLabel(MDL_CTF_LONGITUDINAL_DISPLACEMENT);
     ptrMdOut.removeLabel(MDL_CTF_K);
 
     ptrMdOut.write(fn_out.replaceExtension("xmd"));
 
 }

◆ processImage() [1/2]

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

virtual

Implements XmippMetadataProgram.

Definition at line 45 of file ctf_correct_phase.cpp.

 {
     rowOut = rowIn;
     img.read(fnImg);
     ctf.readFromMdRow(rowIn);
     img().setXmippOrigin();
     ctf.correctPhase(img(),sampling_rate);
     img.write(fnImgOut);
     rowOut.setValue(MDL_IMAGE, fnImgOut);
 }

◆ processImage() [2/2]

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

virtual

Implements XmippMetadataProgram.

Definition at line 96 of file ctf_correct_wiener2d.cpp.

 {
     WF.pad = pad;
     WF.correct_envelope = correct_envelope;
     WF.sampling_rate = sampling_rate;
     WF.wiener_constant = wiener_constant;
     WF.isIsotropic = isIsotropic;
     WF.phase_flipped = phase_flipped;
     WF.applyWienerFilter(fnImg, fnImgOut, rowIn, rowOut);
 
 }

◆ readParams() [1/2]

void ProgCorrectPhaseFlip2D::readParams ( )

virtual

Function in which each program will read parameters that it need. If some error occurs the usage will be printed out.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgCorrectPhaseFlip2D >.

Definition at line 29 of file ctf_correct_phase.cpp.

 {
     XmippMetadataProgram::readParams();
     sampling_rate = getDoubleParam("--sampling_rate");
 }

◆ readParams() [2/2]

void ProgCorrectWiener2D::readParams ( )

virtual

Function in which each program will read parameters that it need. If some error occurs the usage will be printed out.

Reimplemented from XmippMetadataProgram.

Reimplemented in BasicMpiMetadataProgram< ProgCorrectWiener2D >.

Definition at line 30 of file ctf_correct_wiener2d.cpp.

 {
     XmippMetadataProgram::readParams();
     phase_flipped = checkParam("--phase_flipped");
     pad = XMIPP_MAX(1.,getDoubleParam("--pad"));
     isIsotropic = checkParam("--isIsotropic");
     wiener_constant  = getDoubleParam("--wc");
     correct_envelope = checkParam("--correct_envelope");
     sampling_rate = getDoubleParam("--sampling_rate");
 }

◆ write_guinierfile()

void ProgVolumeCorrectBfactor::write_guinierfile	(	const FileName &	fn_guinier,
		std::vector< fit_point2D > &	guinierin,
		std::vector< fit_point2D > &	guinierweighted,
		std::vector< fit_point2D > &	guiniernew,
		double	intercept,
		std::vector< fit_point2D > &	guinierref
	)

Write Guinier plot in a textfile

Definition at line 320 of file volume_correct_bfactor.cpp.

 {
     std::ofstream fh;
     fh.open(fn_guinier.c_str(), std::ios::out);
     if (!fh)
         REPORT_ERROR(ERR_IO_NOWRITE, fn_guinier);
 
     fh << "# 1/d^2   lnF     weighted-lnF   corrected-lnF   (model)\n";
     for (size_t i = 0; i < guinierin.size(); i++)
     {
         fh << (guinierin[i]).x << " " << (guinierin[i]).y << " " << (guinierweighted[i]).y << " " <<(guiniernew[i]).y;
         if (bMode==MODES::BFACTOR_AUTO)
             fh << " " << intercept;
         else if (bMode==MODES::BFACTOR_REF || bMode==MODES::ALLPOINTS_REF)
         {
             fh << " " << (guinierref[i]).y + intercept;
         }
         fh << std::endl;
     }
     fh.close();
 }

Variable Documentation

◆ correct_envelope

bool ProgCorrectWiener2D::correct_envelope

Definition at line 53 of file ctf_correct_wiener2d.h.

◆ ctf [1/2]

CTFDescription ProgCorrectPhaseFlip2D::ctf

Definition at line 50 of file ctf_correct_phase.h.

◆ ctf [2/2]

CTFDescription ProgCorrectWiener2D::ctf

Definition at line 77 of file ctf_correct_wiener2d.h.

◆ Faux

MultidimArray<std::complex<double> > ProgCorrectWiener2D::Faux

Definition at line 82 of file ctf_correct_wiener2d.h.

◆ img [1/2]

Image<double> ProgCorrectPhaseFlip2D::img

Definition at line 49 of file ctf_correct_phase.h.

◆ img [2/2]

Image<double> ProgCorrectWiener2D::img

Definition at line 75 of file ctf_correct_wiener2d.h.

◆ isIsotropic

bool ProgCorrectWiener2D::isIsotropic

Definition at line 51 of file ctf_correct_wiener2d.h.

◆ Mwien

MultidimArray<double> ProgCorrectWiener2D::Mwien

Definition at line 81 of file ctf_correct_wiener2d.h.

◆ pad

double ProgCorrectWiener2D::pad

Padding factor

Definition at line 49 of file ctf_correct_wiener2d.h.

◆ phase_flipped

bool ProgCorrectWiener2D::phase_flipped

Definition at line 46 of file ctf_correct_wiener2d.h.

◆ sampling_rate [1/2]

double ProgCorrectPhaseFlip2D::sampling_rate

Sampling rate.

Definition at line 41 of file ctf_correct_phase.h.

◆ sampling_rate [2/2]

double ProgCorrectWiener2D::sampling_rate

Sampling rate.

Definition at line 59 of file ctf_correct_wiener2d.h.

◆ transformer [1/2]

FourierTransformer ProgCorrectPhaseFlip2D::transformer

Definition at line 52 of file ctf_correct_phase.h.

◆ transformer [2/2]

FourierTransformer ProgCorrectWiener2D::transformer

Definition at line 83 of file ctf_correct_wiener2d.h.

◆ WF

Wiener2D ProgCorrectWiener2D::WF

Definition at line 44 of file ctf_correct_wiener2d.h.

◆ wiener_constant

double ProgCorrectWiener2D::wiener_constant

Wiener filter constant.

Definition at line 56 of file ctf_correct_wiener2d.h.

◆ Xdim [1/2]

size_t ProgCorrectPhaseFlip2D::Xdim

Definition at line 51 of file ctf_correct_phase.h.

◆ Xdim [2/2]

size_t ProgCorrectWiener2D::Xdim

Definition at line 79 of file ctf_correct_wiener2d.h.

◆ Ydim [1/2]

size_t ProgCorrectPhaseFlip2D::Ydim

Definition at line 51 of file ctf_correct_phase.h.

◆ Ydim [2/2]

size_t ProgCorrectWiener2D::Ydim

Definition at line 79 of file ctf_correct_wiener2d.h.

Classes

Functions

Variables

Detailed Description

Function Documentation

◆ apply_allpoints()

◆ apply_bfactor()

◆ apply_snr_weights()

◆ defineParams() [1/2]

◆ defineParams() [2/2]

◆ generateWienerFilter()

◆ get_snr_weights()

◆ make_guinier_plot()

◆ postProcess()

◆ processImage() [1/2]

◆ processImage() [2/2]

◆ readParams() [1/2]

◆ readParams() [2/2]

◆ write_guinierfile()

Variable Documentation

◆ correct_envelope

◆ ctf [1/2]

◆ ctf [2/2]

◆ Faux

◆ img [1/2]

◆ img [2/2]

◆ isIsotropic

◆ Mwien

◆ pad

◆ phase_flipped

◆ sampling_rate [1/2]

◆ sampling_rate [2/2]

◆ transformer [1/2]

◆ transformer [2/2]

◆ WF

◆ wiener_constant

◆ Xdim [1/2]

◆ Xdim [2/2]

◆ Ydim [1/2]

◆ Ydim [2/2]