EMAN::FFTResampleProcessor Class Reference

FFTResampleProcessor resamples an image by clipping the Fourier Transform This is the same as multipyling the FT by a box window, in real space this is a convolution that will induce rippling. More...

#include <processor.h>

Inheritance diagram for EMAN::FFTResampleProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual EMDataprocess (const EMData *const image)
 To proccess an image out-of-place.
virtual void process_inplace (EMData *image)
 To process an image in-place.
string get_desc () const
 Get the descrition of this specific processor.
string get_name () const
 Get the processor's name.
TypeDict get_param_types () const
 Get processor parameter information in a dictionary.

Static Public Member Functions

static ProcessorNEW ()

Static Public Attributes

static const string NAME = "math.fft.resample"

Private Member Functions

void fft_resample (EMData *to, const EMData *const from, const float &sample_rate)
 An internal function that encapsulates a routine common to both process and process inplace.

Detailed Description

FFTResampleProcessor resamples an image by clipping the Fourier Transform This is the same as multipyling the FT by a box window, in real space this is a convolution that will induce rippling.

Hence it should probably be combined with a damping function near the edge Works for even/odd, 1D, 2D and 3D images (completely robust, tested)

Author:
David Woolford
Date:
June 2009
Parameters:
n sampe_rate

Definition at line 3540 of file processor.h.


Member Function Documentation

void FFTResampleProcessor::fft_resample ( EMData to,
const EMData *const   from,
const float &  sample_rate 
) [private]

An internal function that encapsulates a routine common to both process and process inplace.

Parameters:
to the smaller image that will store the shrunken values
from the larger image that will be used to calculate the shrunken values
shrinkfactor the shrink amount

Definition at line 2052 of file processor.cpp.

References EMAN::EMData::clip_inplace(), EMAN::EMData::depad_corner(), EMAN::EMData::do_fft_inplace(), EMAN::EMData::do_ift_inplace(), EMAN::EMData::get_ndim(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::is_complex(), EMAN::EMData::process_inplace(), EMAN::EMData::set_fftodd(), and UnexpectedBehaviorException.

Referenced by process(), and process_inplace().

02052                                                                                                       {
02053         int nx = from->get_xsize();
02054         int ny = from->get_ysize();
02055         int nz = from->get_zsize();
02056 
02057         int new_nx = static_cast<int>( static_cast<float> (nx) / sample_rate);
02058         int new_ny = static_cast<int>( static_cast<float> (ny) / sample_rate);
02059         int new_nz = static_cast<int>( static_cast<float> (nz) / sample_rate);
02060 
02061         if (new_nx == 0) throw UnexpectedBehaviorException("The resample rate causes the pixel dimensions in the x direction to go to zero");
02062         if (new_ny == 0) new_ny = 1;
02063         if (new_nz == 0) new_nz = 1;
02064 
02065         int ndim = from->get_ndim();
02066         if ( ndim < 3 ) {
02067                 new_nz = 1;
02068         }
02069         if ( ndim < 2 ) {
02070                 new_ny = 1;
02071         }
02072 
02073         int fft_x_correction = 1;
02074         if (new_nx % 2 == 0) fft_x_correction = 2;
02075 
02076         int fft_y_correction = 0;
02077         if (ny != 1 && new_ny % 2 == 0 && ny % 2 == 1) fft_y_correction = 1;
02078         else if (ny != 1 && new_ny % 2 == 1 && ny % 2 == 0) fft_y_correction = -1;
02079 
02080         int fft_z_correction = 0;
02081         if (nz != 1 && new_nz % 2 == 0 && nz % 2 == 1) fft_z_correction = 1;
02082         else if (nz != 1 && new_nz % 2 == 1 && nz % 2 == 0) fft_z_correction = -1;
02083 
02084         if ( ! to->is_complex()) to->do_fft_inplace();
02085 
02086         if (ndim != 1) to->process_inplace("xform.fourierorigin.tocenter");
02087 
02088         Region clip(0,(ny-new_ny)/2-fft_y_correction,(nz-new_nz)/2-fft_z_correction,new_nx+fft_x_correction,new_ny,new_nz);
02089         to->clip_inplace(clip);
02090 
02091         if (fft_x_correction == 1) to->set_fftodd(true);
02092         else to->set_fftodd(false);
02093 
02094         if (ndim != 1) to->process_inplace("xform.fourierorigin.tocorner");
02095 
02096         to->do_ift_inplace();
02097         to->depad_corner();
02098 
02099 }

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

03548                         {
03549                                 return "Robust resampling of an image by clipping its Fourier transform.";
03550                         }

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

References NAME.

03553                         {
03554                                 return NAME;
03555                         }

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

References EMAN::EMObject::FLOAT, and EMAN::TypeDict::put().

03562                         {
03563                                 TypeDict d;
03564                                 d.put("n", EMObject::FLOAT, "The sample rate. Less than one enlarges the image, greater than one shrinks it.");
03565                                 return d;
03566                         }

static Processor* EMAN::FFTResampleProcessor::NEW (  )  [inline, static]

Definition at line 3556 of file processor.h.

03557                         {
03558                                 return new FFTResampleProcessor();
03559                         }

EMData * FFTResampleProcessor::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 2017 of file processor.cpp.

References EMAN::EMData::copy(), EMAN::EMData::do_fft(), fft_resample(), InvalidValueException, EMAN::EMData::is_complex(), EMAN::Processor::params, EMAN::EMData::scale_pixel(), EMAN::Dict::set_default(), and EMAN::EMData::update().

02018 {
02019         float sample_rate = params.set_default("n",0.0f);
02020         if (sample_rate <= 0.0F  )  {
02021                 throw InvalidValueException(sample_rate,        "sample rate must be >0 ");
02022         }
02023 
02024         EMData* result;
02025         if (image->is_complex()) result = image->copy();
02026         else result = image->do_fft();
02027         fft_resample(result,image,sample_rate);
02028         // The image may have been padded - we should shift it so that the phase origin is where FFTW expects it
02029         result->update();
02030         result->scale_pixel(sample_rate);
02031         return result;
02032 }

void FFTResampleProcessor::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 2034 of file processor.cpp.

References fft_resample(), ImageFormatException, InvalidValueException, EMAN::EMData::is_complex(), EMAN::Processor::params, EMAN::EMData::scale_pixel(), EMAN::Dict::set_default(), and EMAN::EMData::update().

02035 {
02036         if (image->is_complex()) throw ImageFormatException("Error, the fft resampling processor does not work on complex images");
02037 
02038 
02039         float sample_rate = params.set_default("n",0.0f);
02040         if (sample_rate <= 0.0F  )  {
02041                 throw InvalidValueException(sample_rate,        "sample rate (n) must be >0 ");
02042         }
02043 
02044         fft_resample(image,image,sample_rate);
02045 
02046         image->scale_pixel(sample_rate);
02047         image->update();
02048 
02049 
02050 }


Member Data Documentation

const string FFTResampleProcessor::NAME = "math.fft.resample" [static]

Definition at line 3568 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Thu Nov 17 12:46:23 2011 for EMAN2 by  doxygen 1.4.7