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

05033                 {
05034                         return "Tries to mask out only interesting density using something akin to a flood file approach.";
05035                 }

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

References NAME.

05023                 {
05024                         return NAME;
05025                 }

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

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

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

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

Definition at line 5027 of file processor.h.

05028                 {
05029                         return new AutoMask3D2Processor();
05030                 }

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

06484 {
06485         if (!image) {
06486                 LOGWARN("NULL Image");
06487                 return;
06488         }
06489 
06490         if (image->get_ndim() != 3) {
06491                 throw ImageDimensionException("This processor was only ever designed to work on 3D images.");
06492         }
06493 
06494         /*
06495          The mask writing functionality was removed to comply with an EMAN2 policy which dictates that file io is not allowed from within a processor
06496          To get around this just use the return_mask parameter.
06497         string mask_output = params.set_default("write_mask", "");
06498         if ( mask_output != "") {
06499                 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.");
06500                 if (!EMUtil::is_valid_filename(mask_output)) throw InvalidParameterException("The mask output file name type is invalid or unrecognized");
06501         }
06502         */
06503 
06504         int radius=0;
06505         if (params.has_key("radius")) {
06506                 radius = params["radius"];
06507         }
06508         int nmaxseed=0;
06509         if (params.has_key("nmaxseed")) {
06510                 nmaxseed = params["nmaxseed"];
06511         }
06512 
06513         float threshold=0.0;
06514         if (params.has_key("sigma")) threshold=(float)(image->get_attr("mean"))+(float)(image->get_attr("sigma"))*(float)params["sigma"];
06515         else threshold=params["threshold"];
06516 
06517         int nshells = params["nshells"];
06518         int nshellsgauss = params["nshellsgauss"];
06519         int verbose=params.set_default("verbose",0);
06520 
06521         int nx = image->get_xsize();
06522         int ny = image->get_ysize();
06523         int nz = image->get_zsize();
06524         int nxy=nx*ny;
06525 
06526         EMData *amask = new EMData();
06527         amask->set_size(nx, ny, nz);
06528 
06529         float *dat = image->get_data();
06530         float *dat2 = amask->get_data();
06531         int i,j,k;
06532         size_t l = 0;
06533 
06534         // Seeds with the highest valued pixels
06535         if (nmaxseed>0) {
06536                 vector<Pixel> maxs=image->calc_n_highest_locations(nmaxseed);
06537 
06538                 for (vector<Pixel>::iterator i=maxs.begin(); i<maxs.end(); i++) {
06539                         amask->set_value_at((*i).x,(*i).y,(*i).z,1.0);
06540                         if (verbose) printf("Seed at %d,%d,%d (%1.3f)\n",(*i).x,(*i).y,(*i).z,(*i).value);
06541                 }
06542         }
06543 
06544         // Seeds with a sphere
06545         if (radius>0) {
06546                 // start with an initial sphere
06547                 for (k = -nz / 2; k < nz / 2; ++k) {
06548                         for (j = -ny / 2; j < ny / 2; ++j) {
06549                                 for (i = -nx / 2; i < nx / 2; ++i,++l) {
06550                                         if (abs(k) > radius || abs(j) > radius || abs(i) > radius) continue;
06551                                         if ( (k * k + j * j + i * i) > (radius*radius) || dat[l] < threshold) continue;
06552                                         dat2[l] = 1.0f;
06553                                 }
06554                         }
06555                 }
06556         }
06557 
06558 
06559         // iteratively 'flood fills' the map... recursion would be better
06560         int done=0;
06561         int iter=0;
06562         while (!done) {
06563                 iter++;
06564                 done=1;
06565                 if (verbose && iter%10==0) printf("%d iterations\n",iter);
06566                 for (k=1; k<nz-1; ++k) {
06567                         for (j=1; j<ny-1; ++j) {
06568                                 for (i=1; i<nx-1; ++i) {
06569                                         l=i+j*nx+k*nx*ny;
06570                                         if (dat2[l]) continue;
06571                                         if (dat[l]>threshold && (dat2[l-1]||dat2[l+1]||dat2[l+nx]||dat2[l-nx]||dat2[l-nxy]||dat2[l+nxy])) {
06572                                                 dat2[l]=1.0;
06573                                                 done=0;
06574                                         }
06575                                 }
06576                         }
06577                 }
06578         }
06579 
06580         amask->update();
06581 
06582         if (verbose) printf("extending mask\n");
06583         amask->process_inplace("mask.addshells.gauss", Dict("val1", nshells, "val2", nshellsgauss));
06584 
06585         bool return_mask = params.set_default("return_mask",false);
06586         if (return_mask) {
06587                 // 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.
06588                 memcpy(dat,dat2,image->get_size()*sizeof(float));
06589         } else {
06590                 image->mult(*amask);
06591         }
06592 
06593         // EMAN2 policy is not to allow file io from with a processor
06594         //if (mask_output != "") {
06595         //      amask->write_image(mask_output);
06596         //}
06597 
06598 
06599         delete amask;
06600 }


Member Data Documentation

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

Definition at line 5051 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Mon Jul 19 12:43:53 2010 for EMAN2 by  doxygen 1.4.7