Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

EMAN::NewFourierProcessor Class Reference

Base class for Fourier processors. More...

#include <processor_sparx.h>

Inheritance diagram for EMAN::NewFourierProcessor:

Inheritance graph
[legend]
Collaboration diagram for EMAN::NewFourierProcessor:

Collaboration graph
[legend]
List of all members.

Public Member Functions

TypeDict get_param_types () const
 Get processor parameter information in a dictionary.

Static Public Member Functions

string get_group_desc ()
 Get the description of this group of processors.

Protected Member Functions

virtual void preprocess (EMData *image)
virtual void preprocessandconvertpars (EMData *image)
virtual void setbutterworthdefaults (EMData *image)

Detailed Description

Base class for Fourier processors.

Parameters:
sigma Gaussian sigma (0-.5)
cutoff_abs Processor radius in terms of Nyquist (0-.5)
cutoff_pixels Width in Fourier pixels (0 - size()/2
cutoff_freq Resolution in 1/A (0 - 1 / size*apix)
apix Override A/pix in the image header (changes x,y and z)

Definition at line 87 of file processor_sparx.h.


Member Function Documentation

string EMAN::NewFourierProcessor::get_group_desc  )  [inline, static]
 

Get the description of this group of processors.

This function is defined in a parent class. It gives a introduction to a group of processors.

Returns:
The description of this group of processors.

Reimplemented from EMAN::Processor.

Definition at line 92 of file processor_sparx.h.

00093                 {
00094                         return "Fourier Filter Processors are frequency domain processors. The input image can be either real or Fourier, and the output processed image format corresponds to that of the input file. FourierFilter class is the base class of fourier space processors. The processors can be either low-pass, high-pass, band-pass, or homomorphic. The processor parameters are in absolute frequency units, valid range is ]0,0.5], where 0.5 is Nyquist freqeuncy. ";
00095                 }

TypeDict EMAN::NewFourierProcessor::get_param_types  )  const [inline, virtual]
 

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::Processor.

Reimplemented in EMAN::NewBandpassTopHatProcessor, EMAN::NewHomomorphicTopHatProcessor, EMAN::NewLowpassGaussProcessor, EMAN::NewBandpassGaussProcessor, EMAN::NewHomomorphicGaussProcessor, EMAN::SHIFTProcessor, EMAN::InverseKaiserI0Processor, EMAN::InverseKaiserSinhProcessor, EMAN::NewRadialTableProcessor, EMAN::NewLowpassButterworthProcessor, EMAN::NewHighpassButterworthProcessor, EMAN::NewHomomorphicButterworthProcessor, EMAN::NewLowpassTanhProcessor, EMAN::NewHighpassTanhProcessor, EMAN::NewHomomorphicTanhProcessor, EMAN::NewBandpassTanhProcessor, and EMAN::CTF_Processor.

Definition at line 97 of file processor_sparx.h.

References EMAN::TypeDict::put().

00098                 {
00099                         TypeDict d;
00100 //                      d.put("cutoff_frequency", EMObject::FLOAT, "Absolute [0,0.5] cut-off frequency.");      //use cutoff_abs
00101                         d.put("sigma", EMObject::FLOAT, "Gaussian sigma (0-.5)");                                                       //use cutoff_abs
00102                         d.put("cutoff_abs", EMObject::FLOAT, "Processor radius in terms of Nyquist (0-.5)");
00103                         d.put("cutoff_pixels", EMObject::FLOAT, "Width in Fourier pixels (0 - size()/2");
00104                         d.put("cutoff_freq", EMObject::FLOAT, "Resolution in 1/A (0 - 1 / size*apix)");
00105                         d.put("apix", EMObject::FLOAT, " Override A/pix in the image header (changes x,y and z)");
00106                         return d;
00107                 }

virtual void EMAN::NewFourierProcessor::preprocess EMData image  )  [inline, protected, virtual]
 

Definition at line 110 of file processor_sparx.h.

References EMAN::EMData::get_attr_dict(), and EMAN::EMData::set_attr().

00110                                                         {
00111                         if(params.has_key("apix")) {
00112                                 image->set_attr("apix_x", (float)params["apix"]);
00113                                 image->set_attr("apix_y", (float)params["apix"]);
00114                                 image->set_attr("apix_z", (float)params["apix"]);
00115                         }
00116 
00117                         const Dict dict = image->get_attr_dict();
00118                         if( params.has_key("sigma")) {
00119                                 params["cutoff_abs"] = (float)params["sigma"];
00120                         }
00121                         else if( params.has_key("cutoff_abs") ) {
00122                                 params["sigma"] = (float)params["cutoff_abs"];
00123                         }
00124                         else if( params.has_key("cutoff_freq") ) {
00125                                 float val =  (float)params["cutoff_freq"] * (float)dict["apix_x"]; 
00126                                 params["cutoff_abs"] = val;
00127                                 params["sigma"] = val;
00128                         }
00129                         else if( params.has_key("cutoff_pixels") ) {
00130                                 float val = (0.5f*(float)params["cutoff_pixels"] / (float)dict["nx"]);
00131                                 params["cutoff_abs"] = val;
00132                                 params["sigma"] = val;
00133                         }
00134                 }

virtual void EMAN::NewFourierProcessor::preprocessandconvertpars EMData image  )  [inline, protected, virtual]
 

Definition at line 135 of file processor_sparx.h.

References EMAN::EMData::get_attr_dict(), EMAN::EMData::set_attr(), and sqrt().

00136                 {
00137                         if(params.has_key("apix")) {
00138                                 image->set_attr("apix_x", (float)params["apix"]);
00139                                 image->set_attr("apix_y", (float)params["apix"]);
00140                                 image->set_attr("apix_z", (float)params["apix"]);
00141                         }
00142 
00143                         const Dict dict = image->get_attr_dict();
00144                         if( params.has_key("sigma")) {
00145                                 params["cutoff_abs"] = (float)params["sigma"];
00146                         }
00147                         else if( params.has_key("cutoff_abs") ) {
00148                                 // Here I have added a patch 1/sqrt(2) to compensate for the different Gaussian used in EMAN1 vs EMAN2 (John Flanagan)
00149                                 float val = (float)params["cutoff_abs"] / sqrt(2.0f);
00150                                 params["cutoff_abs"] = val;
00151                                 params["sigma"] = val;
00152                                 
00153                         }
00154                         else if( params.has_key("cutoff_freq") ) {
00155                                 // Here I have added a patch 1/sqrt(2) to compensate for the different Gaussian used in EMAN1 vs EMAN2 (John Flanagan)
00156                                 float val =  (float)params["cutoff_freq"] * (float)dict["apix_x"] / sqrt(2.0f); 
00157                                 params["cutoff_abs"] = val;
00158                                 params["sigma"] = val;
00159                         }
00160                         else if( params.has_key("cutoff_pixels") ) {
00161                                 // Here I have added a patch 1/sqrt(2) to compensate for the different Gaussian used in EMAN1 vs EMAN2 (John Flanagan)
00162                                 float val = (0.5f*(float)params["cutoff_pixels"] / (float)dict["nx"]) / sqrt(2.0f);
00163                                 params["cutoff_abs"] = val;
00164                                 params["sigma"] = val;
00165                         }
00166                 }

virtual void EMAN::NewFourierProcessor::setbutterworthdefaults EMData image  )  [inline, protected, virtual]
 

Definition at line 167 of file processor_sparx.h.

References EMAN::EMData::get_attr_dict(), and log10().

00168                 {
00169                         float highlowratio = 0.15f;
00170                         const Dict dict = image->get_attr_dict();
00171                         
00172                         if(params.has_key("cutoff_abs") && !params.has_key("low_cutoff_frequency"))
00173                         {
00174                                 params["low_cutoff_frequency"] = (float)params["cutoff_abs"];
00175                                 
00176                                 float val = (float)params["low_cutoff_frequency"];
00177                                 params["high_cutoff_frequency"] = highlowratio*log10(1.0f/val) + val;
00178                         }
00179                         
00180                         else if(params.has_key("cutoff_freq") && !params.has_key("low_cutoff_frequency"))
00181                         {
00182                                 params["low_cutoff_frequency"] = (float)params["cutoff_freq"] * (float)dict["apix_x"];
00183                                 
00184                                 float val = (float)params["low_cutoff_frequency"];
00185                                 params["high_cutoff_frequency"] = highlowratio*log10(1.0f/val) + val;  
00186                         }
00187                         
00188                         else if(params.has_key("cutoff_pixels") && !params.has_key("low_cutoff_frequency"))
00189                         {
00190                                 params["low_cutoff_frequency"] = (0.5f*(float)params["cutoff_pixels"] / (float)dict["nx"]);
00191                                 
00192                                 float val = (float)params["low_cutoff_frequency"];
00193                                 params["high_cutoff_frequency"] = highlowratio*log10(1.0f/val) + val;  
00194                         }
00195                         
00196                 }


The documentation for this class was generated from the following file:
Generated on Tue Jun 11 13:43:02 2013 for EMAN2 by  doxygen 1.3.9.1