#include <processor.h>
Inheritance diagram for EMAN::FlattenBackgroundProcessor:


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 | |
| Processor * | NEW () |
Static Public Attributes | |
| const string | NAME = "filter.flattenbackground" |
| 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 |
Definition at line 3617 of file processor.h.
|
|
Get the descrition of this specific processor. This function must be overwritten by a subclass.
Implements EMAN::Processor. Definition at line 3632 of file processor.h. 03633 {
03634 return "Flattens the background by subtracting the local mean";
03635 }
|
|
|
Get the processor's name. Each processor is identified by a unique name.
Implements EMAN::Processor. Definition at line 3622 of file processor.h. 03623 {
03624 return NAME;
03625 }
|
|
|
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 3637 of file processor.h. References EMAN::TypeDict::put(). 03638 {
03639 TypeDict d;
03640 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");
03641 d.put("radius", EMObject::INT, "The radius of circle/sphere that defines the local neighborhood. Exclusive of the mask argument");
03642 return d;
03643 }
|
|
|
Definition at line 3627 of file processor.h. 03628 {
03629 return new FlattenBackgroundProcessor();
03630 }
|
|
|
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.
Implements EMAN::Processor. Definition at line 2637 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(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, InvalidParameterException, EMAN::EMData::mult(), nx, ny, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_size(), and EMAN::EMData::sub(). 02638 {
02639
02640 EMData* mask = params.set_default("mask",(EMData*)0);
02641 int radius = params.set_default("radius",0);
02642
02643 if (radius != 0 && mask != 0) throw InvalidParameterException("Error - the mask and radius parameters are mutually exclusive.");
02644
02645 if (mask == 0 && radius == 0) throw InvalidParameterException("Error - you must specify either the mask or the radius parameter.");
02646
02647 // If the radius isn't 0, then turn the mask into the thing we want...
02648 bool deletemask = false;
02649 if (radius != 0) {
02650 mask = new EMData;
02651 int n = image->get_ndim();
02652 if (n==1){
02653 mask->set_size(2*radius+1);
02654 } else if (n==2) {
02655 mask->set_size(2*radius+1,2*radius+1);
02656 }
02657 else /*n==3*/ {
02658 mask->set_size(2*radius+1,2*radius+1,2*radius+1);
02659 }
02660 // assuming default behavior is to make a circle/sphere with using the radius of the mask
02661 mask->process_inplace("testimage.circlesphere");
02662 }
02663
02664 // Double check that that mask isn't too big
02665 int mnx = mask->get_xsize(); int mny = mask->get_ysize(); int mnz = mask->get_zsize();
02666 int nx = image->get_xsize(); int ny = image->get_ysize(); int nz = image->get_zsize();
02667 int nxc = nx+mnx; int nyc = ny+mny; int nzc = nz+mnz;
02668 if (nz == 1) nzc = 1; // Sanity check
02669 if (ny == 1) nyc = 1; // Sanity check
02670
02671 if ( mnx > nx || mny > ny || mnz > nz)
02672 throw ImageDimensionException("Can not flatten using a mask that is larger than the image.");
02673
02674 // Get the normalization factor
02675 float normfac = 0.0;
02676 for (int i=0; i<mask->get_xsize()*mask->get_ysize()*mask->get_zsize(); ++i){
02677 normfac += mask->get_value_at(i);
02678 }
02679 // If the sum is zero the user probably doesn't understand that determining a measure of the mean requires
02680 // strictly positive numbers. The user has specified a mask that consists entirely of zeros, or the mask
02681 // has a mean of zero.
02682 if (normfac == 0) throw InvalidParameterException("Error - the pixels in the mask sum to zero. This breaks the flattening procedure");
02683 normfac = 1.0f/normfac;
02684
02685 // The mask can now be automatically resized to the dimensions of the image
02686 // bool undoclip = false;
02687
02688 Region r;
02689 if (ny == 1) r = Region((mnx-nxc)/2,nxc);
02690 else if (nz == 1) r = Region((mnx-nxc)/2, (mny-nyc)/2,nxc,nyc);
02691 else r = Region((mnx-nxc)/2, (mny-nyc)/2,(mnz-nzc)/2,nxc,nyc,nzc);
02692 mask->clip_inplace(r,0);
02693 // undoclip = true;
02694 // if ( mnx < nx || mny < ny || mnz < nz) {
02695 // Region r((mnx-nx)/2, (mny-ny)/2,(mnz-nz)/2,nx,ny,nz);
02696 // mask->clip_inplace(r);
02697 // undoclip = true;
02698 // }
02699
02700 Region r2;
02701 if (ny == 1) r2 = Region((nx-nxc)/2,nxc);
02702 else if (nz == 1) r2 = Region((nx-nxc)/2, (ny-nyc)/2,nxc,nyc);
02703 else r2 = Region((nx-nxc)/2, (ny-nyc)/2,(nz-nzc)/2,nxc,nyc,nzc);
02704 image->clip_inplace(r2,image->get_edge_mean());
02705 // Finally do the convolution
02706 EMData* m = image->convolute(mask);
02707 // Normalize so that m is truly the local mean
02708 m->mult(normfac);
02709 // Before we can subtract, the mean must be phase shifted
02710 m->process_inplace("xform.phaseorigin.tocenter");
02711 // Subtract the local mean
02712 // image->write_image("a.mrc");
02713 // m->write_image("b.mrc");
02714 image->sub(*m); // WE'RE DONE!
02715 delete m;
02716
02717 if (deletemask) {
02718 delete mask;
02719 } else { // I clipped it inplace, so undo this clipping so the user gets back what the put in
02720 Region r;
02721 if (ny == 1) r = Region((nxc-mnx)/2,mnx);
02722 else if (nz == 1) r = Region((nxc-mnx)/2, (nyc-mny)/2,mnx,mny);
02723 else r = Region((nxc-mnx)/2, (nyc-mny)/2,(nzc-mnz)/2,mnx,mny,mnz);
02724 mask->clip_inplace(r);
02725 }
02726
02727 Region r3;
02728 if (ny == 1) r3 = Region((nxc-nx)/2,nx);
02729 else if (nz == 1) r3 = Region((nxc-nx)/2, (nyc-ny)/2,nx,ny);
02730 else r3 = Region((nxc-nx)/2, (nyc-ny)/2,(nzc-nz)/2,nx,ny,nz);
02731 image->clip_inplace(r3);
02732 // if ( undoclip ) {
02733 // Region r((nx-mnx)/2, (ny-mny)/2, (nz-mnz)/2,mnx,mny,mnz);
02734 // mask->clip_inplace(r);
02735 // }
02736
02737 }
|
|
|
Definition at line 130 of file processor.cpp. |
1.3.9.1