#include <averager.h>

Inheritance diagram for EMAN::CtfWtFiltAverager:

Collaboration diagram for EMAN::CtfWtFiltAverager:

[legend]

Public Member Functions
	CtfWtFiltAverager ()

void	add_image (EMData *image)
	To add an image to the Averager. More...

EMData *	finish ()
	Finish up the averaging and return the result. More...

string	get_name () const
	Get the Averager's name. More...

string	get_desc () const

void	set_params (const Dict &new_params)
	Set the Averager parameters using a key/value dictionary. More...

Public Member Functions inherited from EMAN::Averager
	Averager ()

virtual	~Averager ()

virtual void	add_image_list (const vector< EMData * > &images)
	To add multiple images to the Averager. More...

virtual void	mult (const float &s)
	Multiply the result image by some floating point constant This is useful when weighting the input images prior to calling add_image - a situation where it is likely you want to divide by the sum of the weights. More...

virtual TypeDict	get_param_types () const
	Get Averager parameter information in a dictionary. More...

Static Public Member Functions
static Averager *	NEW ()

Static Public Attributes
static const string	NAME = "ctf.weight.autofilt"

Protected Attributes
EMData *	results [2]

EMData *	ctfsum [2]

int	nimg [2]

int	eo

Protected Attributes inherited from EMAN::Averager
Dict	params

EMData *	result

Detailed Description

CtfWtAverager.

Definition at line 524 of file averager.h.

Constructor & Destructor Documentation

◆ CtfWtFiltAverager()

CtfWtFiltAverager::CtfWtFiltAverager ( )

Definition at line 1343 of file averager.cpp.

{
        nimg[0]=0;
        nimg[1]=0;
        eo=-1;
}

References eo, and nimg.

Referenced by NEW().

Member Function Documentation

◆ add_image()

void CtfWtFiltAverager::add_image ( EMData * image )

virtual

To add an image to the Averager.

This image will be averaged in this function.

Parameters

image The image to be averaged.

Reimplemented from EMAN::Averager.

Definition at line 1351 of file averager.cpp.

{
        if (!image) {
                return;
        }
 
 
 
        EMData *fft=image->do_fft();
 
        if (nimg[0] >= 1 && !EMUtil::is_same_size(fft, results[0])) {
                LOGERR("%s Averager can only process images of the same size", get_name().c_str());
                return;
        }
 
        if (eo==-1) {
                results[0] = fft->copy_head();
                results[0]->to_zero();
                results[1] = fft->copy_head();
                results[1]->to_zero();
                eo=1;
        }
 
        eo^=1;
        nimg[eo]++;
 
        
        EMData *ctfi = results[0]-> copy();
        if (image->has_attr("ctf")) {
                Ctf *ctf = (Ctf *)image->get_attr("ctf");
 
                float b=ctf->bfactor;
                ctf->bfactor=0;         // no B-factor used in weight, not strictly threadsafe, but shouldn't be a problem
                ctf->compute_2d_complex(ctfi,Ctf::CTF_INTEN);
                ctf->bfactor=b; // return to its original value
                delete ctf;
        }
        else {
                ctfi->to_one();
        }
                
        float *outd = results[eo]->get_data();
        float *ind = fft->get_data();
        float *ctfd = ctfi->get_data();
 
        size_t sz=ctfi->get_xsize()*ctfi->get_ysize();
        for (size_t i = 0; i < sz; i+=2) {
                
                // CTF weight
                outd[i]+=ind[i]*ctfd[i];
                outd[i+1]+=ind[i+1]*ctfd[i];
        }
 
        if (nimg[eo]==1) {
                ctfsum[eo]=ctfi->copy_head();
                ctfsum[eo]->to_zero();
                ctfsum[eo]->add(0.1);           // we start with a value of 0.1 rather than zero to empirically help with situations where the data is incomplete
        }
        ctfsum[eo]->add(*ctfi);
 
        delete fft;
        delete ctfi;
}

References EMAN::Ctf::bfactor, EMAN::Ctf::compute_2d_complex(), copy(), EMAN::Ctf::CTF_INTEN, ctfsum, eo, get_name(), EMAN::EMUtil::is_same_size(), LOGERR, nimg, and results.

◆ finish()

EMData * CtfWtFiltAverager::finish ( )

virtual

Finish up the averaging and return the result.

Returns: The averaged image.

Implements EMAN::Averager.

Definition at line 1415 of file averager.cpp.

{
        if (nimg[0]==0 && nimg[1]==0) return NULL;      // no images
        // Only a single image, so we just return it. No way to filter
        if (nimg[1]==0) {
                EMData *ret=results[0]->do_ift();
                delete results[0];
                delete results[1];
                delete ctfsum[0];
                return ret;
        }
 
        int nx=results[0]->get_xsize();
        int ny=results[0]->get_ysize();
 
        for (int k=0; k<2; k++) {
                float *outd=results[k]->get_data();
                float *ctfsd=ctfsum[k]->get_data();
                for (int j=0; j<ny; j++) {
                        for (int i=0; i<nx; i+=2) {
                                size_t ii=i+j*nx;
                                outd[ii]/=ctfsd[ii];
                                outd[ii+1]/=ctfsd[ii];
                        }
                }
                results[k]->update();
        //      result->set_attr("ctf_total",ctfsum->calc_radial_dist(ctfsum->get_ysize()/2,0,1,false));
                results[0]->set_attr("ctf_wiener_filtered",1);
        }
        
        // compute the Wiener filter from the FSC
        std::vector<float> fsc=results[0]->calc_fourier_shell_correlation(results[1]);
        int third=fsc.size()/3;
        for (int i=third; i<third*2; i++) {
                if (fsc[i]>=.9999) fsc[i]=.9999;
                if (fsc[i]<.001) fsc[i]=.001;
                float snr=2.0*fsc[i]/(1.0-fsc[i]);              // convert the FSC to SNR and multiply by 2
                fsc[i]=snr/(snr+1.0);                                   // to give us the FSC of the combined average, which is also a Wiener filter (depending on whether SNR is squared)
        }
        
        
        results[0]->add(*results[1]);
        
        float c;
        for (int j=-ny/2; j<ny/2; j++) {
                for (int i=0; i<nx/2; i++) {
                        int r=(int)Util::hypot_fast(i,j);
                        if (r>=third) c=0.0;
                        else c=fsc[third+r];
                        results[0]->set_complex_at(i,j,results[0]->get_complex_at(i,j)*c);
                }
        }
        
        EMData *ret=results[0]->do_ift();
        ret->set_attr("ptcl_repr",nimg[0]+nimg[1]);
        
/*      snrsum->write_image("snr.hdf",-1);
        result->write_image("avg.hdf",-1);*/
        
        delete ctfsum[0];
        delete ctfsum[1];
        delete results[0];
        delete results[1];
        results[0]=results[1]=NULL;
        return ret;
}

References ctfsum, get_complex_at(), EMAN::Util::hypot_fast(), nimg, and results.

◆ get_desc()

string EMAN::CtfWtFiltAverager::get_desc ( ) const

inlinevirtual

Implements EMAN::Averager.

Definition at line 537 of file averager.h.

                {
                        return "Average without CTF correction but with CTF weighting and automatic filter estimated from the data. Smoothed SNR can still have large uncertainty, so weighting by envelope-free CTF may provide more uniform results.";
                }

◆ get_name()

string EMAN::CtfWtFiltAverager::get_name ( ) const

inlinevirtual

Get the Averager's name.

Each Averager is identified by a unique name.

Returns: The Averager's name.

Implements EMAN::Averager.

Definition at line 532 of file averager.h.

                {
                        return NAME;
                }

References NAME.

Referenced by add_image().

◆ NEW()

static Averager * EMAN::CtfWtFiltAverager::NEW ( )

inlinestatic

Definition at line 542 of file averager.h.

                {
                        return new CtfWtFiltAverager();
                }

References CtfWtFiltAverager().

◆ set_params()

void EMAN::CtfWtFiltAverager::set_params ( const Dict & new_params )

inlinevirtual

Set the Averager parameters using a key/value dictionary.

Parameters

new_params A dictionary containing the new parameters.

Reimplemented from EMAN::Averager.

Definition at line 547 of file averager.h.

                {
                        params = new_params;
//                      outfile = params["outfile"];
                }

References EMAN::Averager::params.

Member Data Documentation

◆ ctfsum

EMData* EMAN::CtfWtFiltAverager::ctfsum[2]

protected

Definition at line 557 of file averager.h.

Referenced by add_image(), and finish().

◆ eo

int EMAN::CtfWtFiltAverager::eo

protected

Definition at line 558 of file averager.h.

Referenced by add_image(), and CtfWtFiltAverager().

◆ NAME

const string CtfWtFiltAverager::NAME = "ctf.weight.autofilt"

static

Definition at line 553 of file averager.h.

Referenced by get_name().

◆ nimg

int EMAN::CtfWtFiltAverager::nimg[2]

protected

Definition at line 558 of file averager.h.

Referenced by add_image(), CtfWtFiltAverager(), and finish().

◆ results

EMData* EMAN::CtfWtFiltAverager::results[2]

protected

Definition at line 556 of file averager.h.

Referenced by add_image(), and finish().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CtfWtFiltAverager()

Member Function Documentation

◆ add_image()

◆ finish()

◆ get_desc()

◆ get_name()

◆ NEW()

◆ set_params()

Member Data Documentation

◆ ctfsum

◆ eo

◆ NAME

◆ nimg

◆ results