EMAN::ConvolutionKernelProcessor Class Reference

#include <processor.h>

Inheritance diagram for EMAN::ConvolutionKernelProcessor:

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

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.
virtual string get_name () const
 Get the processor's name.
string get_desc () const
 Get the descrition of this specific processor.
virtual 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 = "filter.convolution.kernel"

Detailed Description

Definition at line 6957 of file processor.h.


Member Function Documentation

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

06972                 {
06973                         return "Filters an image with a convolution kernel in real space.";
06974                 }

virtual string EMAN::ConvolutionKernelProcessor::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 6963 of file processor.h.

References NAME.

06964                 {
06965                         return NAME;
06966                 }

virtual TypeDict EMAN::ConvolutionKernelProcessor::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 6975 of file processor.h.

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

06976                 {
06977                         TypeDict d;
06978                         d.put("kernel", EMObject::FLOATARRAY, "the convolution kernel");
06979                         return d;
06980                 }

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

Definition at line 6967 of file processor.h.

06968                 {
06969                         return new ConvolutionKernelProcessor();
06970                 }

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

References EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, InvalidParameterException, EMAN::Processor::params, and sqrt().

09764 {
09765         if (image->get_zsize()!=1) throw ImageDimensionException("Only 2-D images supported");
09766         
09767         EMData* conv = new EMData(image->get_xsize(),image->get_ysize(),1);
09768         vector<float>kernel = params["kernel"];
09769 
09770         if (fmod(sqrt((float)kernel.size()), 1.0f) != 0) throw InvalidParameterException("Convolution kernel must be square!!");
09771         
09772         float* data = image->get_data();
09773         float* cdata = conv->get_data();        // Yes I could use set_value_at_fast, but is still slower than this....
09774         
09775         //I could do the edges by wrapping around, but this is not necessary(such functionality can be iplemented later)
09776         int ks = int(sqrt(float(kernel.size())));
09777         int n = (ks - 1)/2;
09778         int nx = image->get_xsize();
09779         int ny = image->get_ysize();
09780         for (int i = n; i < (nx - n); i++) {
09781                 for (int j = n; j < (ny - n); j++) {
09782                         //now do the convolution
09783                         float cpixel = 0;
09784                         int idx = 0;
09785                         // Perahps I could use some ofrm of Caching to speed things up?
09786                         for (int cx = -n; cx <= n; cx++) {
09787                                 for (int cy = -n; cy <= n; cy++) {
09788                                         cpixel += data[(i+cx) + (j+cy) * nx]*kernel[idx];
09789                                         idx++;
09790                                 }
09791                         }
09792                         cdata[i + j * nx] = cpixel;
09793                 }
09794         }
09795         
09796         return conv;
09797 }

void ConvolutionKernelProcessor::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 9799 of file processor.cpp.

References UnexpectedBehaviorException.

09800 {
09801         throw UnexpectedBehaviorException("Not implemented yet");
09802         
09803         return;
09804 }


Member Data Documentation

const string ConvolutionKernelProcessor::NAME = "filter.convolution.kernel" [static]

Definition at line 6981 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue Jul 12 13:49:50 2011 for EMAN2 by  doxygen 1.4.7