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

EMAN::MedianShrinkProcessor Class Reference

MeanShrinkProcessor shrinks an image by in an integer amount taking the median of the pixel neighbourhood. More...

#include <processor.h>

Inheritance diagram for EMAN::MedianShrinkProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual EMDataprocess (const EMData *const image)
 The medianshrink processor has its own process function to minise memory usage - if this function was not over written the base Processor class would create copy of the input image and hand it to the process_inplace function.
virtual void process_inplace (EMData *image)
 Median shrink the image.
string get_desc () const
 Get the descrition of this specific processor.
virtual string get_name () const
 Get the processor's name.
virtual TypeDict get_param_types () const
 Get processor parameter information in a dictionary.

Static Public Member Functions

ProcessorNEW ()

Static Public Attributes

const string NAME = "math.medianshrink"

Private Member Functions

void accrue_median (EMData *to, const EMData *const from, const int shrink_factor)
 Accrue the local median in the image 'from' to the image 'to' using the given shrinkfactor An internal function that encapsulates a routine common to both process and process inplace.

Detailed Description

MeanShrinkProcessor shrinks an image by in an integer amount taking the median of the pixel neighbourhood.

Author:
David Woolford (But is basically a copy of the old EMData::median_shrink, probably written by Steven Ludtke )
Date:
May 2008
Parameters:
n The shrink factor

Definition at line 3519 of file processor.h.


Member Function Documentation

void MedianShrinkProcessor::accrue_median EMData to,
const EMData *const   from,
const int  shrink_factor
[private]
 

Accrue the local median in the image 'from' to the image 'to' using the given shrinkfactor An internal function that encapsulates a routine common to both process and process inplace.

Parameters:
to the smaller image that will store the calculated median values
from the larger image that will be used to calculate the median values
shrink_factor the shrink amount

Definition at line 2015 of file processor.cpp.

References EMAN::EMData::get_const_data(), EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), nx, ny, rdata, and EMAN::EMData::scale_pixel().

Referenced by process(), and process_inplace().

02016 {
02017 
02018         int nx_old = from->get_xsize();
02019         int ny_old = from->get_ysize();
02020 
02021         int threed_shrink_factor = shrink_factor * shrink_factor;
02022         int z_shrink_factor = 1;
02023         if (from->get_zsize() > 1) {
02024                 threed_shrink_factor *= shrink_factor;
02025                 z_shrink_factor = shrink_factor;
02026         }
02027 
02028         float *mbuf = new float[threed_shrink_factor];
02029 
02030 
02031         int nxy_old = nx_old * ny_old;
02032 
02033         int nx = to->get_xsize();
02034         int ny = to->get_ysize();
02035         int nz = to->get_zsize();
02036         int nxy_new = nx * ny;
02037 
02038         float * rdata = to->get_data();
02039         const float *const data_copy = from->get_const_data();
02040 
02041         for (int l = 0; l < nz; l++) {
02042                 int l_min = l * shrink_factor;
02043                 int l_max = l * shrink_factor + z_shrink_factor;
02044                 size_t cur_l = (size_t)l * nxy_new;
02045 
02046                 for (int j = 0; j < ny; j++) {
02047                         int j_min = j * shrink_factor;
02048                         int j_max = (j + 1) * shrink_factor;
02049                         size_t cur_j = j * nx + cur_l;
02050 
02051                         for (int i = 0; i < nx; i++) {
02052                                 int i_min = i * shrink_factor;
02053                                 int i_max = (i + 1) * shrink_factor;
02054 
02055                                 size_t k = 0;
02056                                 for (int l2 = l_min; l2 < l_max; l2++) {
02057                                         size_t cur_l2 = l2 * nxy_old;
02058 
02059                                         for (int j2 = j_min; j2 < j_max; j2++) {
02060                                                 size_t cur_j2 = j2 * nx_old + cur_l2;
02061 
02062                                                 for (int i2 = i_min; i2 < i_max; i2++) {
02063                                                         mbuf[k] = data_copy[i2 + cur_j2];
02064                                                         ++k;
02065                                                 }
02066                                         }
02067                                 }
02068 
02069                                 for (k = 0; k < size_t(threed_shrink_factor / 2 + 1); k++) {
02070                                         for (int i2 = k + 1; i2 < threed_shrink_factor; i2++) {
02071                                                 if (mbuf[i2] < mbuf[k]) {
02072                                                         float f = mbuf[i2];
02073                                                         mbuf[i2] = mbuf[k];
02074                                                         mbuf[k] = f;
02075                                                 }
02076                                         }
02077                                 }
02078 
02079                                 rdata[i + cur_j] = mbuf[threed_shrink_factor / 2];
02080                         }
02081                 }
02082         }
02083 
02084         if( mbuf )
02085         {
02086                 delete[]mbuf;
02087                 mbuf = 0;
02088         }
02089 
02090         to->scale_pixel((float)shrink_factor);
02091 }

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

03543                 {
03544                         return "Shrink an image by a given amount , using the median value found in the pixel neighborhood.";
03545                 }

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

03548                 {
03549                         return NAME;
03550                 }

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

References EMAN::TypeDict::put().

03557                 {
03558                         TypeDict d;
03559                         d.put("n", EMObject::INT, "The shrink factor");
03560                         return d;
03561                 }

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

Definition at line 3551 of file processor.h.

03552                 {
03553                         return new MedianShrinkProcessor();
03554                 }

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

The medianshrink processor has its own process function to minise memory usage - if this function was not over written the base Processor class would create copy of the input image and hand it to the process_inplace function.

This latter approach mallocs and copies more memory than necessary

Parameters:
image the image that will be used to generate a 'median shrunken' image
Exceptions:
ImageFormatException if the image is complex
InvalidValueException if the shrink amount is not a non zero, positive integer
InvalidValueException if any of the image dimensions are not divisible by the the shrink amount

Reimplemented from EMAN::Processor.

Definition at line 1982 of file processor.cpp.

References accrue_median(), EMAN::EMData::copy_head(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, InvalidValueException, EMAN::EMData::is_complex(), nx, ny, EMAN::Dict::set_default(), EMAN::EMData::set_size(), and EMAN::EMData::update().

01983 {
01984         if (image->is_complex()) throw ImageFormatException("Error, the median shrink processor does not work on complex images");
01985 
01986         int shrink_factor =  params.set_default("n",0);
01987         if (shrink_factor <= 1) {
01988                 throw InvalidValueException(shrink_factor,
01989                                                                         "median shrink: shrink factor must > 1");
01990         }
01991         int nx = image->get_xsize();
01992         int ny = image->get_ysize();
01993         int nz = image->get_zsize();
01994 
01995 
01996 //      if ((nx % shrink_factor != 0) || (ny % shrink_factor != 0) || (nz > 1 && (nz % shrink_factor != 0))) {
01997 //              throw InvalidValueException(shrink_factor, "Image size not divisible by shrink factor");
01998 //      }
01999 
02000 
02001         int shrunken_nx = nx / shrink_factor;
02002         int shrunken_ny = ny / shrink_factor;
02003         int shrunken_nz = 1;
02004         if (nz > 1) shrunken_nz = nz / shrink_factor;
02005 
02006 //      EMData* ret = new EMData(shrunken_nx, shrunken_ny, shrunken_nz);
02007         EMData *ret = image->copy_head();
02008         ret->set_size(shrunken_nx, shrunken_ny, shrunken_nz);
02009 
02010         accrue_median(ret,image,shrink_factor);
02011         ret->update();
02012         return ret;
02013 }

void MedianShrinkProcessor::process_inplace EMData image  )  [virtual]
 

Median shrink the image.

Parameters:
image the image the image that will be 'median shrunken' inplace
Exceptions:
ImageFormatException if the image is complex
InvalidValueException if the shrink amount is not a non zero, positive integer
InvalidValueException if any of the image dimensions are not divisible by the the shrink amount

Implements EMAN::Processor.

Definition at line 1946 of file processor.cpp.

References accrue_median(), EMAN::EMData::copy(), copy(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, InvalidValueException, EMAN::EMData::is_complex(), nx, ny, EMAN::Dict::set_default(), EMAN::EMData::set_size(), and EMAN::EMData::update().

01947 {
01948         if (image->is_complex()) throw ImageFormatException("Error, the median shrink processor does not work on complex images");
01949 
01950         int shrink_factor =  params.set_default("n",0);
01951         if (shrink_factor <= 1) {
01952                 throw InvalidValueException(shrink_factor,
01953                                                                         "median shrink: shrink factor must > 1");
01954         }
01955 
01956         int nx = image->get_xsize();
01957         int ny = image->get_ysize();
01958         int nz = image->get_zsize();
01959 
01960 //      if ((nx % shrink_factor != 0) || (ny % shrink_factor != 0) || (nz > 1 && (nz % shrink_factor != 0))) {
01961 //              throw InvalidValueException(shrink_factor, "Image size not divisible by shrink factor");
01962 //      }
01963 
01964 
01965         int shrunken_nx = nx / shrink_factor;
01966         int shrunken_ny = ny / shrink_factor;
01967         int shrunken_nz = 1;
01968         if (nz > 1) shrunken_nz = nz / shrink_factor;
01969 
01970         EMData* copy = image->copy();
01971         image->set_size(shrunken_nx, shrunken_ny, shrunken_nz);
01972         accrue_median(image,copy,shrink_factor);
01973         image->update();
01974         if( copy )
01975         {
01976                 delete copy;
01977                 copy = 0;
01978         }
01979 }


Member Data Documentation

const string MedianShrinkProcessor::NAME = "math.medianshrink" [static]
 

Definition at line 127 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Fri Aug 10 16:37:17 2012 for EMAN2 by  doxygen 1.3.9.1