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 5011 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 5026 of file processor.h.

05027                 {
05028                         return "Tries to mask out only interesting density using something akin to a flood file approach.";
05029                 }

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 5016 of file processor.h.

References NAME.

05017                 {
05018                         return NAME;
05019                 }

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 5031 of file processor.h.

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

05032                 {
05033                         TypeDict d;
05034                         d.put("radius", EMObject::INT,"Pixel radius of a ball which is used to seed the flood filling operation. ");
05035                         d.put("nmaxseed",EMObject::INT,"Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.");
05036                         d.put("threshold", EMObject::FLOAT, "An isosurface threshold that suitably encases the mass.");
05037                         d.put("sigma", EMObject::FLOAT, "Alternative to threshold based on mean + x*sigma");
05038                         d.put("nshells", EMObject::INT, "The number of dilation operations");
05039                         d.put("nshellsgauss", EMObject::INT, "number of Gaussian pixels to expand, following the dilation operations");
05040                         d.put("return_mask", EMObject::BOOL, "If true the result of the operation will produce the mask, not the masked volume.");
05041                         d.put("verbose", EMObject::INT, "How verbose to be (stdout)");
05042                         return d;
05043                 }

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

Definition at line 5021 of file processor.h.

05022                 {
05023                         return new AutoMask3D2Processor();
05024                 }

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 6525 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().

06526 {
06527         if (!image) {
06528                 LOGWARN("NULL Image");
06529                 return;
06530         }
06531 
06532         if (image->get_ndim() != 3) {
06533                 throw ImageDimensionException("This processor was only ever designed to work on 3D images.");
06534         }
06535 
06536         /*
06537          The mask writing functionality was removed to comply with an EMAN2 policy which dictates that file io is not allowed from within a processor
06538          To get around this just use the return_mask parameter.
06539         string mask_output = params.set_default("write_mask", "");
06540         if ( mask_output != "") {
06541                 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.");
06542                 if (!EMUtil::is_valid_filename(mask_output)) throw InvalidParameterException("The mask output file name type is invalid or unrecognized");
06543         }
06544         */
06545 
06546         int radius=0;
06547         if (params.has_key("radius")) {
06548                 radius = params["radius"];
06549         }
06550         int nmaxseed=0;
06551         if (params.has_key("nmaxseed")) {
06552                 nmaxseed = params["nmaxseed"];
06553         }
06554 
06555         float threshold=0.0;
06556         if (params.has_key("sigma")) threshold=(float)(image->get_attr("mean"))+(float)(image->get_attr("sigma"))*(float)params["sigma"];
06557         else threshold=params["threshold"];
06558 
06559         int nshells = params["nshells"];
06560         int nshellsgauss = params["nshellsgauss"];
06561         int verbose=params.set_default("verbose",0);
06562 
06563         int nx = image->get_xsize();
06564         int ny = image->get_ysize();
06565         int nz = image->get_zsize();
06566         int nxy=nx*ny;
06567 
06568         EMData *amask = new EMData();
06569         amask->set_size(nx, ny, nz);
06570 
06571         float *dat = image->get_data();
06572         float *dat2 = amask->get_data();
06573         int i,j,k;
06574         size_t l = 0;
06575 
06576         // Seeds with the highest valued pixels
06577         if (nmaxseed>0) {
06578                 vector<Pixel> maxs=image->calc_n_highest_locations(nmaxseed);
06579 
06580                 for (vector<Pixel>::iterator i=maxs.begin(); i<maxs.end(); i++) {
06581                         amask->set_value_at((*i).x,(*i).y,(*i).z,1.0);
06582                         if (verbose) printf("Seed at %d,%d,%d (%1.3f)\n",(*i).x,(*i).y,(*i).z,(*i).value);
06583                 }
06584         }
06585 
06586         // Seeds with a sphere
06587         if (radius>0) {
06588                 // start with an initial sphere
06589                 for (k = -nz / 2; k < nz / 2; ++k) {
06590                         for (j = -ny / 2; j < ny / 2; ++j) {
06591                                 for (i = -nx / 2; i < nx / 2; ++i,++l) {
06592                                         if (abs(k) > radius || abs(j) > radius || abs(i) > radius) continue;
06593                                         if ( (k * k + j * j + i * i) > (radius*radius) || dat[l] < threshold) continue;
06594                                         dat2[l] = 1.0f;
06595                                 }
06596                         }
06597                 }
06598         }
06599 
06600 
06601         // iteratively 'flood fills' the map... recursion would be better
06602         int done=0;
06603         int iter=0;
06604         while (!done) {
06605                 iter++;
06606                 done=1;
06607                 if (verbose && iter%10==0) printf("%d iterations\n",iter);
06608                 for (k=1; k<nz-1; ++k) {
06609                         for (j=1; j<ny-1; ++j) {
06610                                 for (i=1; i<nx-1; ++i) {
06611                                         l=i+j*nx+k*nx*ny;
06612                                         if (dat2[l]) continue;
06613                                         if (dat[l]>threshold && (dat2[l-1]||dat2[l+1]||dat2[l+nx]||dat2[l-nx]||dat2[l-nxy]||dat2[l+nxy])) {
06614                                                 dat2[l]=1.0;
06615                                                 done=0;
06616                                         }
06617                                 }
06618                         }
06619                 }
06620         }
06621 
06622         amask->update();
06623 
06624         if (verbose) printf("extending mask\n");
06625         amask->process_inplace("mask.addshells.gauss", Dict("val1", nshells, "val2", nshellsgauss));
06626 
06627         bool return_mask = params.set_default("return_mask",false);
06628         if (return_mask) {
06629                 // 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.
06630                 memcpy(dat,dat2,image->get_size()*sizeof(float));
06631         } else {
06632                 image->mult(*amask);
06633         }
06634 
06635         // EMAN2 policy is not to allow file io from with a processor
06636         //if (mask_output != "") {
06637         //      amask->write_image(mask_output);
06638         //}
06639 
06640 
06641         delete amask;
06642 }


Member Data Documentation

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

Definition at line 5045 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Thu Nov 17 12:46:43 2011 for EMAN2 by  doxygen 1.4.7