EMAN::MatchSFProcessor Class Reference

Sets the structure factor To match a second provided image/volume. More...

#include <processor.h>

Inheritance diagram for EMAN::MatchSFProcessor:

Collaboration diagram for EMAN::MatchSFProcessor:

Public Member Functions
virtual string	get_name () const
	Get the processor's name. More...
virtual string	get_desc () const
	Get the descrition of this specific processor. More...
virtual TypeDict	get_param_types () const
	Get processor parameter information in a dictionary. More...
Public Member Functions inherited from EMAN::FourierAnlProcessor
void	process_inplace (EMData *image)
	To process an image in-place. More...
Public Member Functions inherited from EMAN::Processor
virtual	~Processor ()
virtual EMData *	process (const EMData *const image)
	To proccess an image out-of-place. More...
virtual void	process_list_inplace (vector< EMData * > &images)
	To process multiple images using the same algorithm. More...
virtual Dict	get_params () const
	Get the processor parameters in a key/value dictionary. More...
virtual void	set_params (const Dict &new_params)
	Set the processor parameters using a key/value dictionary. More...

Static Public Member Functions
static Processor *	NEW ()
Static Public Member Functions inherited from EMAN::FourierAnlProcessor
static string	get_group_desc ()
Static Public Member Functions inherited from EMAN::Processor
static string	get_group_desc ()
	Get the description of this group of processors. More...
static void	EMFourierFilterInPlace (EMData *fimage, Dict params)
	Compute a Fourier-filter processed image in place. More...
static EMData *	EMFourierFilter (EMData *fimage, Dict params)
	Compute a Fourier-processor processed image without altering the original image. More...

Static Public Attributes
static const string	NAME = "filter.matchto"

Protected Member Functions
void	create_radial_func (vector< float > &radial_mask, EMData *image) const
Protected Member Functions inherited from EMAN::FourierAnlProcessor
virtual void	preprocess (EMData *)

Additional Inherited Members
Public Types inherited from EMAN::Processor
enum	fourier_filter_types {   TOP_HAT_LOW_PASS , TOP_HAT_HIGH_PASS , TOP_HAT_BAND_PASS , TOP_HOMOMORPHIC ,   GAUSS_LOW_PASS , GAUSS_HIGH_PASS , GAUSS_BAND_PASS , GAUSS_INVERSE ,   GAUSS_HOMOMORPHIC , BUTTERWORTH_LOW_PASS , BUTTERWORTH_HIGH_PASS , BUTTERWORTH_HOMOMORPHIC ,   KAISER_I0 , KAISER_SINH , KAISER_I0_INVERSE , KAISER_SINH_INVERSE ,   SHIFT , TANH_LOW_PASS , TANH_HIGH_PASS , TANH_HOMOMORPHIC ,   TANH_BAND_PASS , RADIAL_TABLE , CTF_ }
	Fourier filter Processor type enum. More...
Protected Attributes inherited from EMAN::Processor
Dict	params

Detailed Description

Sets the structure factor To match a second provided image/volume.

Parameters

to	EMData object to match to. Make sure apix values are set properly

Definition at line 7870 of file processor.h.

Member Function Documentation

create_radial_func()

void MatchSFProcessor::create_radial_func ( vector< float > &  radial_mask, EMData *  image  ) const

protectedvirtual

Implements EMAN::FourierAnlProcessor.

Definition at line 8226 of file processor.cpp.

                                                                                  {
        // The radial mask comes in with the existing radial image profile
        // The radial mask runs from 0 to the 1-D Nyquist (it leaves out the corners in Fourier space)
 
        EMData *to = params["to"];
        float apixto = to->get_attr("apix_x");
        bool bydot = params.set_default("bydot",false);
        float keephires = params.set_default("keephires",false);
 
        if (to->get_ysize() != image->get_ysize()) throw ImageDimensionException("Fatal Error: filter.matchto - image sizes must match");
 
        // This method is similar to that used by math.sub.optimal
        // It scales such that the average dot product at each resolution is matched,
        // but negative values (phase flips) are set to zero.
        if (bydot) {
                // Note that 'image' is guaranteed to be the FFT already
                EMData *tofft;
                if (to->is_complex()) tofft=to;
                else tofft=to->do_fft();
 
                float cornerscale;
                if (image->get_zsize()>1) cornerscale=sqrt(3.0);
                else cornerscale=sqrt(2.0);
 
                int ny=image->get_ysize();
                int ny2=(int)floor(image->get_ysize()*cornerscale/2);
                vector <float>norm(ny2+1);
                for (int i=0; i<ny2; i++) norm[i]=rad[i]=0;
 
                for (int y=-ny; y<ny; y++) {
                        for (int x=0; x<ny; x++) {                                      // intentionally skipping the final pixel in x
                                int r=int(Util::hypot_fast(x,y));
                                if (r>ny2) continue;
                                std::complex<float> v1=image->get_complex_at(x,y);
                                std::complex<float> v2=tofft->get_complex_at(x,y);
                                rad[r]+=(double)(v1.real()*v2.real()+v1.imag()*v2.imag());
                                norm[r]+=(double)(v2.real()*v2.real()+v2.imag()*v2.imag());
                        }
                }
                float radmean=0.0f;
                for (int i=0; i<ny2; i++) {
                        rad[i]=(rad[i]/norm[i]<0)?0.0:rad[i]/norm[i];
                        radmean+=rad[i];
                }
                radmean/=ny2;
 
                if (keephires) {
                        for (int i=0; i<ny2; i++) {
                                if (rad[i]<radmean/100.0) rad[i]=radmean/100.0;
                        }
                }
 
                if (!to->is_complex()) delete tofft;
                return;
        }
 
        // This simply divides one radial intensity profile by the other
        if (to->is_complex()) {
                vector<float> rd=to->calc_radial_dist(rad.size(),0,1.0f,1);
                for (size_t i=0; i<rd.size(); ++i) {
                        if (rad[i]>0) rad[i]=sqrt(rd[i]/rad[i]);
                }
        }
        else {
                EMData *tmp=to->do_fft();
                vector<float> rd=tmp->calc_radial_dist(rad.size(),0,1.0f,1);
                for (size_t i=0; i<rd.size(); ++i) {
                        if (rad[i]>0) rad[i]=sqrt(rd[i]/rad[i]);
                }
                delete tmp;
        }
 
        // This makes sure that the filter never falls below 0.01 of the mean filter value so we keep something at all resolutions
        if (keephires) {
                float radmean=0.0f;
                for (int i=0; i<rad.size(); i++) radmean+=rad[i];
                radmean/=rad.size();
                for (int i=0; i<rad.size(); i++) {
                        if (rad[i]<radmean/100.0) rad[i]=radmean/100.0;
                }
        }
 
 
}

References EMAN::EMData::calc_radial_dist(), EMAN::Util::hypot_fast(), ImageDimensionException, EMAN::Processor::params, EMAN::Dict::set_default(), sqrt(), x, and y.

get_desc()

virtual string EMAN::MatchSFProcessor::get_desc ( ) const

inlinevirtual

Get the descrition of this specific processor.

This function must be overwritten by a subclass.

Returns

The description of this processor.

Implements EMAN::Processor.

Definition at line 7879 of file processor.h.

                {
                        return "Filters the image so its 1-D power spectrum matches a second image. Optionally can incorporate a dot product to better match noise.";
                }

get_name()

virtual string EMAN::MatchSFProcessor::get_name ( ) const

inlinevirtual

Get the processor's name.

Each processor is identified by a unique name.

Returns

The processor's name.

Implements EMAN::Processor.

Definition at line 7874 of file processor.h.

                {
                        return NAME;
                }

References NAME.

get_param_types()

virtual TypeDict EMAN::MatchSFProcessor::get_param_types ( ) const

inlinevirtual

Get processor parameter information in a dictionary.

Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.

Returns

A dictionary containing the parameter info.

Reimplemented from EMAN::FourierAnlProcessor.

Definition at line 7889 of file processor.h.

                {
                        TypeDict d;
                        d.put("to", EMObject::EMDATA, "The image to match with. Make sure apix values are correct.");
                        d.put("bydot", EMObject::BOOL, "Rather than matching the intensity profile, uses the complex dot product as a function of resolution to match only the portion that agrees.");
                        d.put("keephires", EMObject::BOOL, "If the reference being matched is heavily filtered, total information loss may occur at some resolutions. This insures that some information is kept at all resolutions.");
                        d.put("return_radial", EMObject::BOOL, "Return the radial filter function as an attribute (filter_curve)");
                        d.put("interpolate", EMObject::BOOL, "Whether or not to interpolate the radial scaling function. Default=true");
                        return d;
                }

References EMAN::EMObject::BOOL, EMAN::EMObject::EMDATA, and EMAN::TypeDict::put().

NEW()

static Processor * EMAN::MatchSFProcessor::NEW ( )

inlinestatic

Definition at line 7884 of file processor.h.

                {
                        return new MatchSFProcessor();
                }

Member Data Documentation

NAME

const string MatchSFProcessor::NAME = "filter.matchto"

static

Definition at line 7900 of file processor.h.

Referenced by get_name().

---

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

• processor.h
• processor.cpp