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

EMAN::FlattenBackgroundProcessor Class Reference

Flattens the background by subtracting the local mean. More...

#include <processor.h>

Inheritance diagram for EMAN::FlattenBackgroundProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

void process_inplace (EMData *image)
 To process an image in-place.
string get_name () const
 Get the processor's name.
string get_desc () const
 Get the descrition of this specific processor.
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.flattenbackground"

Detailed Description

Flattens the background by subtracting the local mean.

Parameters:
map an EMData object that defines the extent of the local neighbourhood - will be used for convolution
radius exclusive of the mask parameter, this defines the radius of a circle/sphere that will be used for local mean subtraction
Author:
David Woolford
Date:
April 2008

Definition at line 3652 of file processor.h.


Member Function Documentation

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

03668                         {
03669                                 return "Flattens the background by subtracting the local mean";
03670                         }

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

References NAME.

03658                         {
03659                                 return NAME;
03660                         }

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

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

03673                         {
03674                                 TypeDict d;
03675                                 d.put("mask", EMObject::EMDATA, "A mask the defines the local neighborhood that will be used to find the local mean. Exclusive of the radius argument");
03676                                 d.put("radius", EMObject::INT, "The radius of circle/sphere that defines the local neighborhood. Exclusive of the mask argument");
03677                                 return d;
03678                         }

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

Definition at line 3662 of file processor.h.

03663                         {
03664                                 return new FlattenBackgroundProcessor();
03665                         }

void FlattenBackgroundProcessor::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 2590 of file processor.cpp.

References EMAN::EMData::clip_inplace(), EMAN::EMData::convolute(), EMAN::EMData::get_edge_mean(), EMAN::EMData::get_ndim(), EMAN::EMData::get_value_at(), get_xsize(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, InvalidParameterException, EMAN::EMData::mult(), EMAN::Processor::params, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_size(), and EMAN::EMData::sub().

02591 {
02592 
02593         EMData* mask = params.set_default("mask",(EMData*)0);
02594         int radius = params.set_default("radius",0);
02595 
02596         if (radius != 0 && mask != 0) throw InvalidParameterException("Error - the mask and radius parameters are mutually exclusive.");
02597 
02598         if (mask == 0 && radius == 0) throw InvalidParameterException("Error - you must specify either the mask or the radius parameter.");
02599 
02600         // If the radius isn't 0, then turn the mask into the thing we want...
02601         bool deletemask = false;
02602         if (radius != 0) {
02603                 mask = new EMData;
02604                 int n = image->get_ndim();
02605                 if (n==1){
02606                         mask->set_size(2*radius+1);
02607                 } else if (n==2) {
02608                         mask->set_size(2*radius+1,2*radius+1);
02609                 }
02610                 else /*n==3*/ {
02611                         mask->set_size(2*radius+1,2*radius+1,2*radius+1);
02612                 }
02613                 // assuming default behavior is to make a circle/sphere with using the radius of the mask
02614                 mask->process_inplace("testimage.circlesphere");
02615         }
02616 
02617         // Double check that that mask isn't too big
02618         int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize();
02619         int nx = image->get_xsize(); int ny = image->get_ysize(); int nz = image->get_zsize();
02620         int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
02621         if (nz == 1) nzc = 1; // Sanity check
02622         if (ny == 1) nyc = 1; // Sanity check
02623 
02624         if ( mnx > nx || mny > ny || mnz > nz)
02625                 throw ImageDimensionException("Can not flatten using a mask that is larger than the image.");
02626 
02627         // Get the normalization factor
02628         float normfac = 0.0;
02629         for (int i=0; i<mask->get_xsize()*mask->get_ysize()*mask->get_zsize(); ++i){
02630                 normfac += mask->get_value_at(i);
02631         }
02632         // If the sum is zero the user probably doesn't understand that determining a measure of the mean requires
02633         // strictly positive numbers. The user has specified a mask that consists entirely of zeros, or the mask
02634         // has a mean of zero.
02635         if (normfac == 0) throw InvalidParameterException("Error - the pixels in the mask sum to zero. This breaks the flattening procedure");
02636         normfac = 1.0f/normfac;
02637 
02638         // The mask can now be automatically resized to the dimensions of the image
02639 //      bool undoclip = false;
02640 
02641         Region r;
02642         if (ny == 1) r = Region((mnx-nxc)/2,nxc);
02643         else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
02644         else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
02645         mask->clip_inplace(r,0);
02646 //      undoclip = true;
02647 //      if ( mnx < nx || mny < ny || mnz < nz) {
02648 //              Region r((mnx-nx)/2, (mny-ny)/2,(mnz-nz)/2,nx,ny,nz);
02649 //              mask->clip_inplace(r);
02650 //              undoclip = true;
02651 //      }
02652 
02653         Region r2;
02654         if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
02655         else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
02656         else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
02657         image->clip_inplace(r2,image->get_edge_mean());
02658         // Finally do the convolution
02659         EMData* m = image->convolute(mask);
02660         // Normalize so that m is truly the local mean
02661         m->mult(normfac);
02662         // Before we can subtract, the mean must be phase shifted
02663         m->process_inplace("xform.phaseorigin.tocenter");
02664         // Subtract the local mean
02665 //      image->write_image("a.mrc");
02666 //      m->write_image("b.mrc");
02667         image->sub(*m); // WE'RE DONE!
02668         delete m;
02669 
02670         if (deletemask) {
02671                 delete mask;
02672         } else { // I clipped it inplace, so undo this clipping so the user gets back what the put in
02673                 Region r;
02674                 if (ny == 1) r = Region((nxc-mnx)/2,mnx);
02675                 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny);
02676                 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz);
02677                 mask->clip_inplace(r);
02678         }
02679 
02680         Region r3;
02681         if (ny == 1) r3 = Region((nxc-nx)/2,nx);
02682         else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
02683         else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
02684         image->clip_inplace(r3);
02685 //      if ( undoclip ) {
02686 //              Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz);
02687 //              mask->clip_inplace(r);
02688 //      }
02689 
02690 }


Member Data Documentation

const string FlattenBackgroundProcessor::NAME = "filter.flattenbackground" [static]
 

Definition at line 3680 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue May 25 17:37:20 2010 for EMAN2 by  doxygen 1.4.4