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

EMAN::AmpweightFourierProcessor Class Reference

Multiplies each Fourier pixel by its amplitude. More...

#include <processor.h>

Inheritance diagram for EMAN::AmpweightFourierProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

string get_name () const
 Get the processor's name.
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

static ProcessorNEW ()

Static Public Attributes

static const string NAME = "filter.ampweight"

Protected Attributes

EMDatasum
int dosqrt

Detailed Description

Multiplies each Fourier pixel by its amplitude.

Parameters:
sum Adds the weights to sum for normalization
sqrt Weights using sqrt of the amplitude if set

Definition at line 443 of file processor.h.


Member Function Documentation

string EMAN::AmpweightFourierProcessor::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 474 of file processor.h.

00475                 {
00476                         return "Multiplies each Fourier pixel by its amplitude";
00477                 }

string EMAN::AmpweightFourierProcessor::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 446 of file processor.h.

References NAME.

00447                 {
00448                         return NAME;
00449                 }

TypeDict EMAN::AmpweightFourierProcessor::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 461 of file processor.h.

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

00462                 {
00463                         TypeDict d;
00464                         d.put("sum", EMObject::EMDATA, "Adds the weights to sum for normalization");
00465                         d.put("sqrt", EMObject::INT, "Weights using sqrt of the amplitude if set");
00466                         return d;
00467                 }

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

Definition at line 469 of file processor.h.

00470                 {
00471                         return new AmpweightFourierProcessor();
00472                 }

void AmpweightFourierProcessor::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 756 of file processor.cpp.

References EMAN::EMData::do_fft(), EMAN::EMData::do_ift(), dosqrt, EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::is_complex(), LOGWARN, sum, and EMAN::EMData::update().

00757 {
00758         EMData *fft;
00759         float *fftd;
00760         int i,f=0;
00761 //      static float sum1=0,sum1a=0;
00762 //      static double sum2=0,sum2a=0;
00763 
00764         if (!image) {
00765                 LOGWARN("NULL Image");
00766                 return;
00767         }
00768 
00769         if (!image->is_complex()) {
00770                 fft = image->do_fft();
00771                 fftd = fft->get_data();
00772                 f=1;
00773         }
00774         else {
00775                 fft=image;
00776                 fftd=image->get_data();
00777         }
00778         float *sumd = NULL;
00779         if (sum) sumd=sum->get_data();
00780 //printf("%d %d    %d %d\n",fft->get_xsize(),fft->get_ysize(),sum->get_xsize(),sum->get_ysize());
00781         int n = fft->get_xsize()*fft->get_ysize()*fft->get_zsize();
00782         for (i=0; i<n; i+=2) {
00783                 float c;
00784                 if (dosqrt) c=pow(fftd[i]*fftd[i]+fftd[i+1]*fftd[i+1],0.25f);
00785 #ifdef  _WIN32
00786                 else c = static_cast<float>(_hypot(fftd[i],fftd[i+1]));
00787 #else
00788                 else c = static_cast<float>(hypot(fftd[i],fftd[i+1]));
00789 #endif  //_WIN32
00790                 if (c==0) c=1.0e-30f;   // prevents divide by zero in normalization
00791                 fftd[i]*=c;
00792                 fftd[i+1]*=c;
00793                 if (sumd) { sumd[i]+=c; sumd[i+1]+=0; }
00794 
00795                 // debugging
00796 /*              if (i==290*1+12) {
00797                         sum1+=fftd[i];
00798                         sum2+=fftd[i];
00799                         printf("%f\t%f\t%f\t%f\t%f\t%f\n",sum1,sum2,fftd[i],fftd[i+1],sumd[i],c);
00800                 }
00801                 if (i==290*50+60) {
00802                         sum1a+=fftd[i];
00803                         sum2a+=fftd[i];
00804                         printf("%f\t%f\t%f\t%f\t%f\t%f\n",sum1a,sum2a,fftd[i],fftd[i+1],sumd[i],c);
00805         }*/
00806         }
00807 
00808         if (f) {
00809                 fft->update();
00810                 EMData *ift=fft->do_ift();
00811                 memcpy(image->get_data(),ift->get_data(),n*sizeof(float));
00812                 delete fft;
00813                 delete ift;
00814         }
00815 
00816         sum->update();
00817         image->update();
00818 
00819 }

void EMAN::AmpweightFourierProcessor::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 453 of file processor.h.

References dosqrt, EMAN::Processor::params, and sum.

00454                 {
00455                         params = new_params;
00456                         sum = params["sum"];
00457                         dosqrt = params["sqrt"];
00458 //                      printf("%s %f\n",params.keys()[0].c_str(),lowpass);
00459                 }


Member Data Documentation

int EMAN::AmpweightFourierProcessor::dosqrt [protected]
 

Definition at line 483 of file processor.h.

Referenced by process_inplace(), and set_params().

const string AmpweightFourierProcessor::NAME = "filter.ampweight" [static]
 

Definition at line 479 of file processor.h.

Referenced by get_name().

EMData* EMAN::AmpweightFourierProcessor::sum [protected]
 

Definition at line 482 of file processor.h.

Referenced by process_inplace(), and set_params().


The documentation for this class was generated from the following files:
Generated on Mon Jul 19 13:06:21 2010 for EMAN2 by  doxygen 1.4.4