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

EMAN::Wiener2DFourierProcessor Class Reference

Wiener filter based on a Ctf object either in the image header. More...

#include <processor.h>

Inheritance diagram for EMAN::Wiener2DFourierProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

string get_name () const
 Get the processor's name.
virtual EMDataprocess (const EMData *const image)
 To proccess an image out-of-place.
void process_inplace (EMData *image)
 To process an image in-place.
void set_params (const Dict &new_params)
 Set the processor parameters using a key/value dictionary.
TypeDict get_param_types () const
 Get processor parameter information in a dictionary.
string get_desc () const
 Get the descrition of this specific processor.

Static Public Member Functions

ProcessorNEW ()

Static Public Attributes

const string NAME = "filter.wiener2d"

Protected Attributes

Ctfctf

Detailed Description

Wiener filter based on a Ctf object either in the image header.

Parameters:
ctf[in] A Ctf object to use
Author:
Steve Ludtke
Date:
2008/11/03

Definition at line 845 of file processor.h.


Member Function Documentation

string EMAN::Wiener2DFourierProcessor::get_desc  )  const [inline, virtual]
 

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 876 of file processor.h.

00877                 {
00878                         return "Applies a 2-D Wiener filter to an image based on its Ctf parameters";
00879                 }

string EMAN::Wiener2DFourierProcessor::get_name  )  const [inline, virtual]
 

Get the processor's name.

Each processor is identified by a unique name.

Returns:
The processor's name.

Implements EMAN::Processor.

Definition at line 848 of file processor.h.

00849                 {
00850                         return NAME;
00851                 }

TypeDict EMAN::Wiener2DFourierProcessor::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.

Definition at line 864 of file processor.h.

References EMAN::TypeDict::put().

00865                 {
00866                         TypeDict d;
00867                         d.put("ctf", EMObject::EMDATA, "Ctf object to use for Wiener filter parameters");
00868                         return d;
00869                 }

Processor* EMAN::Wiener2DFourierProcessor::NEW  )  [inline, static]
 

Definition at line 871 of file processor.h.

00872                 {
00873                         return new Wiener2DFourierProcessor();
00874                 }

EMData * Wiener2DFourierProcessor::process const EMData *const   image  )  [virtual]
 

To proccess an image out-of-place.

For those processors which can only be processed out-of-place, override this function to give the right behavior.

Parameters:
image The image will be copied, actual process happen on copy of image.
Returns:
the image processing result, may or may not be the same size of the input image

Reimplemented from EMAN::Processor.

Definition at line 1084 of file processor.cpp.

References EMAN::Ctf::compute_2d_complex(), EMAN::EMData::copy_head(), ctf, EMAN::EMData::do_fft(), EMAN::EMData::do_ift(), EMAN::EMData::get_attr(), in, EMAN::EMData::is_complex(), and EMAN::EMData::mult().

Referenced by process_inplace().

01085 {
01086         const EMData *in2 = 0;
01087         if (in->is_complex()) in2=in;
01088         else in=in->do_fft();
01089 
01090         EMData *filt = in->copy_head();
01091         Ctf *ictf = ctf;
01092 
01093         if (!ictf) ctf=(Ctf *)in->get_attr("ctf");
01094 
01095         ictf->compute_2d_complex(filt,Ctf::CTF_WIENER_FILTER);
01096         filt->mult(*in2);
01097         EMData *ret=filt->do_ift();
01098 
01099         delete filt;
01100         if (!in->is_complex()) delete in2;
01101 
01102         if(!ictf && ctf) {delete ctf; ctf=0;}
01103         return(ret);
01104 /*      const EMData *fft;
01105         float *fftd;
01106         int f=0;
01107 
01108         if (!image) {
01109                 LOGWARN("NULL Image");
01110                 return ret;
01111         }
01112 
01113         if (!image->is_complex()) {
01114                 fft = image->do_fft();
01115                 fftd = fft->get_data();
01116                 f=1;
01117         }
01118         else {
01119                 fft=image;
01120                 fftd=image->get_data();
01121         }
01122         powd=image->get_data();
01123 
01124         int bad=0;
01125         for (int i=0; i<image->get_xsize()*image->get_ysize(); i+=2) {
01126                 snr=(fftd[i]*fftd[i]+fftd[i+1]*fftd[i+1]-powd[i])/powd[i];
01127                 if (snr<0) { bad++; snr=0; }
01128 
01129         }
01130 
01131         print("%d bad pixels\n",snr);
01132 */      return ret;
01133 
01134 }

void Wiener2DFourierProcessor::process_inplace EMData image  )  [virtual]
 

To process an image in-place.

For those processors which can only be processed out-of-place, override this function to just print out some error message to remind user call the out-of-place version.

Parameters:
image The image to be processed.

Implements EMAN::Processor.

Definition at line 1136 of file processor.cpp.

References EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), process(), and EMAN::EMData::update().

01136                                                             {
01137         EMData *tmp=process(image);
01138         memcpy(image->get_data(),tmp->get_data(),image->get_xsize()*image->get_ysize()*image->get_zsize()*sizeof(float));
01139         delete tmp;
01140         image->update();
01141         return;
01142 }

void EMAN::Wiener2DFourierProcessor::set_params const Dict new_params  )  [inline, virtual]
 

Set the processor parameters using a key/value dictionary.

Parameters:
new_params A dictionary containing the new parameters.

Reimplemented from EMAN::Processor.

Definition at line 857 of file processor.h.

00858                 {
00859                         params = new_params;
00860                         ctf = params["ctf"];
00861 //                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
00862                 }


Member Data Documentation

Ctf* EMAN::Wiener2DFourierProcessor::ctf [protected]
 

Definition at line 884 of file processor.h.

Referenced by process().

const string Wiener2DFourierProcessor::NAME = "filter.wiener2d" [static]
 

Definition at line 67 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 13:48:21 2013 for EMAN2 by  doxygen 1.3.9.1