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

04993                 {
04994                         return "Tries to mask out only interesting density using something akin to a flood file approach.";
04995                 }

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

References NAME.

04983                 {
04984                         return NAME;
04985                 }

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

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

04998                 {
04999                         TypeDict d;
05000                         d.put("radius", EMObject::INT,"Pixel radius of a ball which is used to seed the flood filling operation. ");
05001                         d.put("nmaxseed",EMObject::INT,"Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.");
05002                         d.put("threshold", EMObject::FLOAT, "An isosurface threshold that suitably encases the mass.");
05003                         d.put("sigma", EMObject::FLOAT, "Alternative to threshold based on mean + x*sigma");
05004                         d.put("nshells", EMObject::INT, "The number of dilation operations");
05005                         d.put("nshellsgauss", EMObject::INT, "number of Gaussian pixels to expand, following the dilation operations");
05006                         d.put("return_mask", EMObject::BOOL, "If true the result of the operation will produce the mask, not the masked volume.");
05007                         d.put("verbose", EMObject::INT, "How verbose to be (stdout)");
05008                         return d;
05009                 }

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

Definition at line 4987 of file processor.h.

04988                 {
04989                         return new AutoMask3D2Processor();
04990                 }

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

06377 {
06378         if (!image) {
06379                 LOGWARN("NULL Image");
06380                 return;
06381         }
06382 
06383         if (image->get_ndim() != 3) {
06384                 throw ImageDimensionException("This processor was only ever designed to work on 3D images.");
06385         }
06386 
06387         /*
06388          The mask writing functionality was removed to comply with an EMAN2 policy which dictates that file io is not allowed from within a processor
06389          To get around this just use the return_mask parameter.
06390         string mask_output = params.set_default("write_mask", "");
06391         if ( mask_output != "") {
06392                 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.");
06393                 if (!EMUtil::is_valid_filename(mask_output)) throw InvalidParameterException("The mask output file name type is invalid or unrecognized");
06394         }
06395         */
06396 
06397         int radius=0;
06398         if (params.has_key("radius")) {
06399                 radius = params["radius"];
06400         }
06401         int nmaxseed=0;
06402         if (params.has_key("nmaxseed")) {
06403                 nmaxseed = params["nmaxseed"];
06404         }
06405 
06406         float threshold=0.0;
06407         if (params.has_key("sigma")) threshold=(float)(image->get_attr("mean"))+(float)(image->get_attr("sigma"))*(float)params["sigma"];
06408         else threshold=params["threshold"];
06409 
06410         int nshells = params["nshells"];
06411         int nshellsgauss = params["nshellsgauss"];
06412         int verbose=params.set_default("verbose",0);
06413 
06414         int nx = image->get_xsize();
06415         int ny = image->get_ysize();
06416         int nz = image->get_zsize();
06417         int nxy=nx*ny;
06418 
06419         EMData *amask = new EMData();
06420         amask->set_size(nx, ny, nz);
06421 
06422         float *dat = image->get_data();
06423         float *dat2 = amask->get_data();
06424         int i,j,k;
06425         size_t l = 0;
06426 
06427         // Seeds with the highest valued pixels
06428         if (nmaxseed>0) {
06429                 vector<Pixel> maxs=image->calc_n_highest_locations(nmaxseed);
06430 
06431                 for (vector<Pixel>::iterator i=maxs.begin(); i<maxs.end(); i++) {
06432                         amask->set_value_at((*i).x,(*i).y,(*i).z,1.0);
06433                         if (verbose) printf("Seed at %d,%d,%d (%1.3f)\n",(*i).x,(*i).y,(*i).z,(*i).value);
06434                 }
06435         }
06436 
06437         // Seeds with a sphere
06438         if (radius>0) {
06439                 // start with an initial sphere
06440                 for (k = -nz / 2; k < nz / 2; ++k) {
06441                         for (j = -ny / 2; j < ny / 2; ++j) {
06442                                 for (i = -nx / 2; i < nx / 2; ++i,++l) {
06443                                         if (abs(k) > radius || abs(j) > radius || abs(i) > radius) continue;
06444                                         if ( (k * k + j * j + i * i) > (radius*radius) || dat[l] < threshold) continue;
06445                                         dat2[l] = 1.0f;
06446                                 }
06447                         }
06448                 }
06449         }
06450 
06451 
06452         // iteratively 'flood fills' the map... recursion would be better
06453         int done=0;
06454         int iter=0;
06455         while (!done) {
06456                 iter++;
06457                 done=1;
06458                 if (verbose && iter%10==0) printf("%d iterations\n",iter);
06459                 for (k=1; k<nz-1; ++k) {
06460                         for (j=1; j<ny-1; ++j) {
06461                                 for (i=1; i<nx-1; ++i) {
06462                                         l=i+j*nx+k*nx*ny;
06463                                         if (dat2[l]) continue;
06464                                         if (dat[l]>threshold && (dat2[l-1]||dat2[l+1]||dat2[l+nx]||dat2[l-nx]||dat2[l-nxy]||dat2[l+nxy])) {
06465                                                 dat2[l]=1.0;
06466                                                 done=0;
06467                                         }
06468                                 }
06469                         }
06470                 }
06471         }
06472 
06473         amask->update();
06474 
06475         if (verbose) printf("extending mask\n");
06476         amask->process_inplace("mask.addshells.gauss", Dict("val1", nshells, "val2", nshellsgauss));
06477 
06478         bool return_mask = params.set_default("return_mask",false);
06479         if (return_mask) {
06480                 // 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.
06481                 memcpy(dat,dat2,image->get_size()*sizeof(float));
06482         } else {
06483                 image->mult(*amask);
06484         }
06485 
06486         // EMAN2 policy is not to allow file io from with a processor
06487         //if (mask_output != "") {
06488         //      amask->write_image(mask_output);
06489         //}
06490 
06491 
06492         delete amask;
06493 }


Member Data Documentation

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

Definition at line 5011 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue May 25 17:17:19 2010 for EMAN2 by  doxygen 1.4.7