EMAN::AutoMask3D2Processor Class Reference

Tries to mask out only interesting density. More...

#include <processor.h>

Inheritance diagram for EMAN::AutoMask3D2Processor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual void process_inplace (EMData *image)
 To process an image in-place.
virtual string get_name () const
 Get the processor's name.
virtual 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 = "mask.auto3d"

Detailed Description

Tries to mask out only interesting density.

Parameters:
radius Pixel radius of a ball which is used to seed the flood filling operation
threshold An isosurface threshold that suitably encases the mass
nshells The number of dilation operations
nshellsgauss number of Gaussian pixels to expand, following the dilation operations If true the result of the operation will produce the mask, not the masked volume

Definition at line 5056 of file processor.h.


Member Function Documentation

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

05072                 {
05073                         return "Tries to mask out only interesting density using something akin to a flood file approach.";
05074                 }

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

References NAME.

05062                 {
05063                         return NAME;
05064                 }

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

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

05077                 {
05078                         TypeDict d;
05079                         d.put("radius", EMObject::INT,"Pixel radius of a ball which is used to seed the flood filling operation. ");
05080                         d.put("nmaxseed",EMObject::INT,"Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.");
05081                         d.put("threshold", EMObject::FLOAT, "An isosurface threshold that suitably encases the mass.");
05082                         d.put("sigma", EMObject::FLOAT, "Alternative to threshold based on mean + x*sigma");
05083                         d.put("nshells", EMObject::INT, "The number of dilation operations");
05084                         d.put("nshellsgauss", EMObject::INT, "number of Gaussian pixels to expand, following the dilation operations");
05085                         d.put("return_mask", EMObject::BOOL, "If true the result of the operation will produce the mask, not the masked volume.");
05086                         d.put("verbose", EMObject::INT, "How verbose to be (stdout)");
05087                         return d;
05088                 }

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

Definition at line 5066 of file processor.h.

05067                 {
05068                         return new AutoMask3D2Processor();
05069                 }

void AutoMask3D2Processor::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 6597 of file processor.cpp.

References abs, EMAN::EMData::calc_n_highest_locations(), EMAN::EMData::get_attr(), EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_size(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::Dict::has_key(), ImageDimensionException, LOGWARN, EMAN::EMData::mult(), EMAN::Processor::params, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_size(), EMAN::EMData::set_value_at(), and EMAN::EMData::update().

06598 {
06599         if (!image) {
06600                 LOGWARN("NULL Image");
06601                 return;
06602         }
06603 
06604         if (image->get_ndim() != 3) {
06605                 throw ImageDimensionException("This processor was only ever designed to work on 3D images.");
06606         }
06607 
06608         /*
06609          The mask writing functionality was removed to comply with an EMAN2 policy which dictates that file io is not allowed from within a processor
06610          To get around this just use the return_mask parameter.
06611         string mask_output = params.set_default("write_mask", "");
06612         if ( mask_output != "") {
06613                 if (Util::is_file_exist(mask_output) ) throw InvalidParameterException("The mask output file name already exists. Please remove it if you don't need it.");
06614                 if (!EMUtil::is_valid_filename(mask_output)) throw InvalidParameterException("The mask output file name type is invalid or unrecognized");
06615         }
06616         */
06617 
06618         int radius=0;
06619         if (params.has_key("radius")) {
06620                 radius = params["radius"];
06621         }
06622         int nmaxseed=0;
06623         if (params.has_key("nmaxseed")) {
06624                 nmaxseed = params["nmaxseed"];
06625         }
06626 
06627         float threshold=0.0;
06628         if (params.has_key("sigma")) threshold=(float)(image->get_attr("mean"))+(float)(image->get_attr("sigma"))*(float)params["sigma"];
06629         else threshold=params["threshold"];
06630 
06631         int nshells = params["nshells"];
06632         int nshellsgauss = params["nshellsgauss"];
06633         int verbose=params.set_default("verbose",0);
06634 
06635         int nx = image->get_xsize();
06636         int ny = image->get_ysize();
06637         int nz = image->get_zsize();
06638         int nxy=nx*ny;
06639 
06640         EMData *amask = new EMData();
06641         amask->set_size(nx, ny, nz);
06642 
06643         float *dat = image->get_data();
06644         float *dat2 = amask->get_data();
06645         int i,j,k;
06646         size_t l = 0;
06647 
06648         // Seeds with the highest valued pixels
06649         if (nmaxseed>0) {
06650                 vector<Pixel> maxs=image->calc_n_highest_locations(nmaxseed);
06651 
06652                 for (vector<Pixel>::iterator i=maxs.begin(); i<maxs.end(); i++) {
06653                         amask->set_value_at((*i).x,(*i).y,(*i).z,1.0);
06654                         if (verbose) printf("Seed at %d,%d,%d (%1.3f)\n",(*i).x,(*i).y,(*i).z,(*i).value);
06655                 }
06656         }
06657 
06658         // Seeds with a sphere
06659         if (radius>0) {
06660                 // start with an initial sphere
06661                 for (k = -nz / 2; k < nz / 2; ++k) {
06662                         for (j = -ny / 2; j < ny / 2; ++j) {
06663                                 for (i = -nx / 2; i < nx / 2; ++i,++l) {
06664                                         if (abs(k) > radius || abs(j) > radius || abs(i) > radius) continue;
06665                                         if ( (k * k + j * j + i * i) > (radius*radius) || dat[l] < threshold) continue;
06666                                         dat2[l] = 1.0f;
06667                                 }
06668                         }
06669                 }
06670         }
06671 
06672 
06673         // iteratively 'flood fills' the map... recursion would be better
06674         int done=0;
06675         int iter=0;
06676         while (!done) {
06677                 iter++;
06678                 done=1;
06679                 if (verbose && iter%10==0) printf("%d iterations\n",iter);
06680                 for (k=1; k<nz-1; ++k) {
06681                         for (j=1; j<ny-1; ++j) {
06682                                 for (i=1; i<nx-1; ++i) {
06683                                         l=i+j*nx+k*nx*ny;
06684                                         if (dat2[l]) continue;
06685                                         if (dat[l]>threshold && (dat2[l-1]||dat2[l+1]||dat2[l+nx]||dat2[l-nx]||dat2[l-nxy]||dat2[l+nxy])) {
06686                                                 dat2[l]=1.0;
06687                                                 done=0;
06688                                         }
06689                                 }
06690                         }
06691                 }
06692         }
06693 
06694         amask->update();
06695 
06696         if (verbose) printf("extending mask\n");
06697         amask->process_inplace("mask.addshells.gauss", Dict("val1", nshells, "val2", nshellsgauss));
06698 
06699         bool return_mask = params.set_default("return_mask",false);
06700         if (return_mask) {
06701                 // Yes there is probably a much more efficient way of getting the mask itself, but I am only providing a stop gap at the moment.
06702                 memcpy(dat,dat2,image->get_size()*sizeof(float));
06703         } else {
06704                 image->mult(*amask);
06705         }
06706 
06707         // EMAN2 policy is not to allow file io from with a processor
06708         //if (mask_output != "") {
06709         //      amask->write_image(mask_output);
06710         //}
06711 
06712 
06713         delete amask;
06714 }


Member Data Documentation

const string AutoMask3D2Processor::NAME = "mask.auto3d" [static]

Definition at line 5090 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Thu May 3 10:10:36 2012 for EMAN2 by  doxygen 1.4.7