Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

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

ProcessorNEW ()

Static Public Attributes

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

04902                 {
04903                         return "Tries to mask out only interesting density using something akin to a flood file approach.";
04904                 }

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

04892                 {
04893                         return NAME;
04894                 }

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

References EMAN::TypeDict::put().

04907                 {
04908                         TypeDict d;
04909                         d.put("radius", EMObject::INT,"Pixel radius of a ball which is used to seed the flood filling operation. ");
04910                         d.put("nmaxseed",EMObject::INT,"Use the n highest valued pixels in the map as a seed. Alternative to radius. Useful for viruses.");
04911                         d.put("threshold", EMObject::FLOAT, "An isosurface threshold that suitably encases the mass.");
04912                         d.put("sigma", EMObject::FLOAT, "Alternative to threshold based on mean + x*sigma");
04913                         d.put("nshells", EMObject::INT, "The number of dilation operations");
04914                         d.put("nshellsgauss", EMObject::INT, "number of Gaussian pixels to expand, following the dilation operations");
04915                         d.put("return_mask", EMObject::BOOL, "If true the result of the operation will produce the mask, not the masked volume.");
04916                         d.put("verbose", EMObject::INT, "How verbose to be (stdout)");
04917                         return d;
04918                 }

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

Definition at line 4896 of file processor.h.

04897                 {
04898                         return new AutoMask3D2Processor();
04899                 }

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 6409 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(), nx, ny, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_size(), EMAN::EMData::set_value_at(), and EMAN::EMData::update().

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


Member Data Documentation

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

Definition at line 166 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Thu Mar 10 23:00:18 2011 for EMAN2 by  doxygen 1.3.9.1