EMAN::CtfCAutoAverager Class Reference

CtfCWautoAverager averages the images with CTF correction with a Wiener filter. More...

#include <averager.h>

Inheritance diagram for EMAN::CtfCAutoAverager:

Collaboration diagram for EMAN::CtfCAutoAverager:

Public Member Functions
	CtfCAutoAverager ()
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.auto"

Protected Attributes
EMData *	snrsum
int	nimg
Protected Attributes inherited from EMAN::Averager
Dict	params
EMData *	result

Detailed Description

CtfCWautoAverager averages the images with CTF correction with a Wiener filter.

The Weiner filter is estimated directly from the data.

Definition at line 565 of file averager.h.

Constructor & Destructor Documentation

CtfCAutoAverager()

CtfCAutoAverager::CtfCAutoAverager

(

)

Definition at line 1131 of file averager.cpp.

        : nimg(0)
{
 
}

Referenced by NEW().

Member Function Documentation

add_image()

void CtfCAutoAverager::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 1138 of file averager.cpp.

{
        if (!image) {
                return;
        }
 
 
 
        EMData *fft=image->do_fft();
 
        if (nimg >= 1 && !EMUtil::is_same_size(fft, result)) {
                LOGERR("%s Averager can only process images of the same size", get_name().c_str());
                return;
        }
 
        nimg++;
        if (nimg == 1) {
                result = fft->copy_head();
                result->to_zero();
        }
 
        Ctf *ctf = (Ctf *)image->get_attr("ctf");
        float b=ctf->bfactor;
        ctf->bfactor=0;                 // NO B-FACTOR CORRECTION !
 
        EMData *snr = result -> copy();
        ctf->compute_2d_complex(snr,Ctf::CTF_SNR);
        EMData *ctfi = result-> copy();
        ctf->compute_2d_complex(ctfi,Ctf::CTF_AMP);
 
        ctf->bfactor=b; // return to its original value
 
        float *outd = result->get_data();
        float *ind = fft->get_data();
        float *snrd = snr->get_data();
        float *ctfd = ctfi->get_data();
 
        size_t sz=snr->get_xsize()*snr->get_ysize();
        for (size_t i = 0; i < sz; i+=2) {
                if (snrd[i]<=0) snrd[i]=0.001;          // used to be 0. Trying to insure that there is always at least a little signal used. In cases with dense particles, SNR may be dramatically underestimated
                ctfd[i]=fabs(ctfd[i]);
                
                // This limits the maximum possible amplification in CTF correction to 10x
                if (ctfd[i]<.05)  ctfd[i]=0.05f;
//              {
//                      if (snrd[i]<=0) ctfd[i]=.05f;
//                      else ctfd[i]=snrd[i]*10.0f;
//              }
                
                // SNR weight and CTF correction
                outd[i]+=ind[i]*snrd[i]/ctfd[i];
                outd[i+1]+=ind[i+1]*snrd[i]/ctfd[i];
        }
 
        if (nimg==1) {
                snrsum=snr->copy_head();
                float *ssnrd=snrsum->get_data();
                // we're only using the real component, for Wiener filter we put 1.0 in R, but for just SNR weight we use 0
                for (size_t i = 0; i < sz; i+=2) { ssnrd[i]=0.0; ssnrd[i+1]=0.0; }
        }
        snr->process_inplace("math.absvalue");
        snrsum->add(*snr);
 
        delete ctf;
        delete fft;
        delete snr;
        delete ctfi;
}

References EMAN::Ctf::bfactor, EMAN::Ctf::compute_2d_complex(), copy(), EMAN::Ctf::CTF_AMP, EMAN::Ctf::CTF_SNR, get_name(), EMAN::EMUtil::is_same_size(), LOGERR, nimg, EMAN::Averager::result, and snrsum.

finish()

EMData * CtfCAutoAverager::finish ( )

virtual

Finish up the averaging and return the result.

Returns

The averaged image.

Implements EMAN::Averager.

Definition at line 1207 of file averager.cpp.

{
/*      EMData *tmp=result->do_ift();
        tmp->write_image("ctfcw.hdf",0);
        delete tmp;
 
        tmp=snrsum->do_ift();
        tmp->write_image("ctfcw.hdf",1);
        delete tmp;*/
 
//      snrsum->write_image("snrsum.hdf",-1);
        //size_t sz=result->get_xsize()*result->get_ysize();
        int nx=result->get_xsize();
        int ny=result->get_ysize();     
        float *snrsd=snrsum->get_data();
        float *outd=result->get_data();
 
        int rm=(ny-2)*(ny-2)/4;
        for (int j=0; j<ny; j++) {
                for (int i=0; i<nx; i+=2) {
                        size_t ii=i+j*nx;
                        if ((j<ny/2 && i*i/4+j*j>rm) ||(j>=ny/2 && i*i/4+(ny-j)*(ny-j)>rm) || snrsd[ii]==0) { outd[ii]=outd[ii+1]=0; continue; }
                        // we aren't wiener filtering, but if the total SNR is too low, we don't want TOO much exaggeration of noise
                        if (snrsd[ii]<.05) {            
                                outd[ii]*=20.0;         // 1/0.05
                                outd[ii+1]*=20.0;
                        }
                        else {
                                outd[ii]/=snrsd[ii];            // snrsd contains total SNR
                                outd[ii+1]/=snrsd[ii];
                        }
                }
        }
        result->update();
        result->set_attr("ptcl_repr",nimg);
        result->set_attr("ctf_snr_total",snrsum->calc_radial_dist(snrsum->get_ysize()/2,0,1,false));
        result->set_attr("ctf_wiener_filtered",0);
        
/*      snrsum->write_image("snr.hdf",-1);
        result->write_image("avg.hdf",-1);*/
        
        delete snrsum;
        EMData *ret=result->do_ift();
        delete result;
        result=NULL;
        return ret;
}

References EMAN::EMData::calc_radial_dist(), nimg, EMAN::Averager::result, and snrsum.

get_desc()

string EMAN::CtfCAutoAverager::get_desc ( ) const

inlinevirtual

Implements EMAN::Averager.

Definition at line 578 of file averager.h.

                {
                        return "Averaging with automatic CTF correction and SNR weight. No B-factor correction (as this is best done in 3-D). Bases estimated SSNR on CTF parameters, so requires EMAN2 CTF parameters.";
                }

get_name()

string EMAN::CtfCAutoAverager::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 573 of file averager.h.

                {
                        return NAME;
                }

References NAME.

Referenced by add_image().

NEW()

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

inlinestatic

Definition at line 583 of file averager.h.

                {
                        return new CtfCAutoAverager();
                }

References CtfCAutoAverager().

set_params()

void EMAN::CtfCAutoAverager::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 588 of file averager.h.

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

References EMAN::Averager::params.

Member Data Documentation

NAME

const string CtfCAutoAverager::NAME = "ctf.auto"

static

Definition at line 594 of file averager.h.

Referenced by get_name().

nimg

int EMAN::CtfCAutoAverager::nimg

protected

Definition at line 598 of file averager.h.

Referenced by add_image(), and finish().

snrsum

EMData* EMAN::CtfCAutoAverager::snrsum

protected

Definition at line 597 of file averager.h.

Referenced by add_image(), and finish().

---

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

• averager.h
• averager.cpp