#include <processor.h>
Inheritance diagram for EMAN::MedianShrinkProcessor:
Public Member Functions | |
virtual EMData * | process (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 | |
Processor * | NEW () |
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. |
n | The shrink factor |
Definition at line 3521 of file processor.h.
|
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.
Definition at line 2017 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(). 02018 { 02019 02020 int nx_old = from->get_xsize(); 02021 int ny_old = from->get_ysize(); 02022 02023 int threed_shrink_factor = shrink_factor * shrink_factor; 02024 int z_shrink_factor = 1; 02025 if (from->get_zsize() > 1) { 02026 threed_shrink_factor *= shrink_factor; 02027 z_shrink_factor = shrink_factor; 02028 } 02029 02030 float *mbuf = new float[threed_shrink_factor]; 02031 02032 02033 int nxy_old = nx_old * ny_old; 02034 02035 int nx = to->get_xsize(); 02036 int ny = to->get_ysize(); 02037 int nz = to->get_zsize(); 02038 int nxy_new = nx * ny; 02039 02040 float * rdata = to->get_data(); 02041 const float *const data_copy = from->get_const_data(); 02042 02043 for (int l = 0; l < nz; l++) { 02044 int l_min = l * shrink_factor; 02045 int l_max = l * shrink_factor + z_shrink_factor; 02046 size_t cur_l = (size_t)l * nxy_new; 02047 02048 for (int j = 0; j < ny; j++) { 02049 int j_min = j * shrink_factor; 02050 int j_max = (j + 1) * shrink_factor; 02051 size_t cur_j = j * nx + cur_l; 02052 02053 for (int i = 0; i < nx; i++) { 02054 int i_min = i * shrink_factor; 02055 int i_max = (i + 1) * shrink_factor; 02056 02057 size_t k = 0; 02058 for (int l2 = l_min; l2 < l_max; l2++) { 02059 size_t cur_l2 = l2 * nxy_old; 02060 02061 for (int j2 = j_min; j2 < j_max; j2++) { 02062 size_t cur_j2 = j2 * nx_old + cur_l2; 02063 02064 for (int i2 = i_min; i2 < i_max; i2++) { 02065 mbuf[k] = data_copy[i2 + cur_j2]; 02066 ++k; 02067 } 02068 } 02069 } 02070 02071 for (k = 0; k < size_t(threed_shrink_factor / 2 + 1); k++) { 02072 for (int i2 = k + 1; i2 < threed_shrink_factor; i2++) { 02073 if (mbuf[i2] < mbuf[k]) { 02074 float f = mbuf[i2]; 02075 mbuf[i2] = mbuf[k]; 02076 mbuf[k] = f; 02077 } 02078 } 02079 } 02080 02081 rdata[i + cur_j] = mbuf[threed_shrink_factor / 2]; 02082 } 02083 } 02084 } 02085 02086 if( mbuf ) 02087 { 02088 delete[]mbuf; 02089 mbuf = 0; 02090 } 02091 02092 to->scale_pixel((float)shrink_factor); 02093 }
|
|
Get the descrition of this specific processor. This function must be overwritten by a subclass.
Implements EMAN::Processor. Definition at line 3544 of file processor.h. 03545 { 03546 return "Shrink an image by a given amount , using the median value found in the pixel neighborhood."; 03547 }
|
|
Get the processor's name. Each processor is identified by a unique name.
Implements EMAN::Processor. Definition at line 3549 of file processor.h. 03550 {
03551 return NAME;
03552 }
|
|
Get processor parameter information in a dictionary. Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.
Reimplemented from EMAN::Processor. Definition at line 3558 of file processor.h. References EMAN::TypeDict::put(). 03559 { 03560 TypeDict d; 03561 d.put("n", EMObject::INT, "The shrink factor"); 03562 return d; 03563 }
|
|
Definition at line 3553 of file processor.h. 03554 { 03555 return new MedianShrinkProcessor(); 03556 }
|
|
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
Reimplemented from EMAN::Processor. Definition at line 1984 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(). 01985 { 01986 if (image->is_complex()) throw ImageFormatException("Error, the median shrink processor does not work on complex images"); 01987 01988 int shrink_factor = params.set_default("n",0); 01989 if (shrink_factor <= 1) { 01990 throw InvalidValueException(shrink_factor, 01991 "median shrink: shrink factor must > 1"); 01992 } 01993 int nx = image->get_xsize(); 01994 int ny = image->get_ysize(); 01995 int nz = image->get_zsize(); 01996 01997 01998 // if ((nx % shrink_factor != 0) || (ny % shrink_factor != 0) || (nz > 1 && (nz % shrink_factor != 0))) { 01999 // throw InvalidValueException(shrink_factor, "Image size not divisible by shrink factor"); 02000 // } 02001 02002 02003 int shrunken_nx = nx / shrink_factor; 02004 int shrunken_ny = ny / shrink_factor; 02005 int shrunken_nz = 1; 02006 if (nz > 1) shrunken_nz = nz / shrink_factor; 02007 02008 // EMData* ret = new EMData(shrunken_nx, shrunken_ny, shrunken_nz); 02009 EMData *ret = image->copy_head(); 02010 ret->set_size(shrunken_nx, shrunken_ny, shrunken_nz); 02011 02012 accrue_median(ret,image,shrink_factor); 02013 ret->update(); 02014 return ret; 02015 }
|
|
Median shrink the image.
Implements EMAN::Processor. Definition at line 1948 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(). 01949 { 01950 if (image->is_complex()) throw ImageFormatException("Error, the median shrink processor does not work on complex images"); 01951 01952 int shrink_factor = params.set_default("n",0); 01953 if (shrink_factor <= 1) { 01954 throw InvalidValueException(shrink_factor, 01955 "median shrink: shrink factor must > 1"); 01956 } 01957 01958 int nx = image->get_xsize(); 01959 int ny = image->get_ysize(); 01960 int nz = image->get_zsize(); 01961 01962 // if ((nx % shrink_factor != 0) || (ny % shrink_factor != 0) || (nz > 1 && (nz % shrink_factor != 0))) { 01963 // throw InvalidValueException(shrink_factor, "Image size not divisible by shrink factor"); 01964 // } 01965 01966 01967 int shrunken_nx = nx / shrink_factor; 01968 int shrunken_ny = ny / shrink_factor; 01969 int shrunken_nz = 1; 01970 if (nz > 1) shrunken_nz = nz / shrink_factor; 01971 01972 EMData* copy = image->copy(); 01973 image->set_size(shrunken_nx, shrunken_ny, shrunken_nz); 01974 accrue_median(image,copy,shrink_factor); 01975 image->update(); 01976 if( copy ) 01977 { 01978 delete copy; 01979 copy = 0; 01980 } 01981 }
|
|
Definition at line 127 of file processor.cpp. |