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

EMAN::DistanceSegmentProcessor Class Reference

Segment a volume into subvolumes based on a center separation value. More...

#include <processor.h>

Inheritance diagram for EMAN::DistanceSegmentProcessor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

string get_name () const
 Get the processor's name.
virtual EMDataprocess (const EMData *const image)
 To proccess an image out-of-place.
void process_inplace (EMData *image)
 To process an image in-place.
TypeDict get_param_types () const
 Get processor parameter information in a dictionary.
string get_desc () const
 Get the descrition of this specific processor.

Static Public Member Functions

static ProcessorNEW ()

Static Public Attributes

static const string NAME = "segment.distance"

Detailed Description

Segment a volume into subvolumes based on a center separation value.

For linear densities such as skeletons this should fill linear regions with uniformly separated points

Author:
Steve Ludtke
Date:
2010/07/14

Definition at line 679 of file processor.h.


Member Function Documentation

string EMAN::DistanceSegmentProcessor::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 705 of file processor.h.

00706                 {
00707                         return "Segments a volume into pieces separated by distances in the specified range.";
00708                 }

string EMAN::DistanceSegmentProcessor::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 682 of file processor.h.

References NAME.

00683                 {
00684                         return NAME;
00685                 }

TypeDict EMAN::DistanceSegmentProcessor::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 690 of file processor.h.

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

00691                 {
00692                         TypeDict d ;
00693                         d.put("thr",EMObject::FLOAT,"Optional : Isosurface threshold value. Pixels below this will not be segment centers (default = 0.9)");
00694                         d.put("minsegsep",EMObject::FLOAT,"Required: Minimum segment separation in pixels. Segments too close will trigger a reseed");
00695                         d.put("maxsegsep",EMObject::FLOAT,"Required: Maximum segment separation in pixels. Segments too close will trigger a reseed");
00696                         d.put("verbose",EMObject::INT,"Be verbose while running");
00697                         return d;
00698                 }

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

Definition at line 700 of file processor.h.

00701                 {
00702                         return new DistanceSegmentProcessor();
00703                 }

EMData * DistanceSegmentProcessor::process const EMData *const   image  )  [virtual]
 

To proccess an image out-of-place.

For those processors which can only be processed out-of-place, override this function to give the right behavior.

Parameters:
image The image will be copied, actual process happen on copy of image.
Returns:
the image processing result, may or may not be the same size of the input image

Reimplemented from EMAN::Processor.

Definition at line 828 of file processor.cpp.

References EMAN::EMData::calc_highest_locations(), EMAN::EMData::copy(), EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::Util::hypot3(), nx, ny, EMAN::Processor::params, EMAN::EMData::set_attr(), EMAN::Dict::set_default(), EMAN::EMData::set_value_at(), x, EMAN::Pixel::x, y, EMAN::Pixel::y, and EMAN::Pixel::z.

00829 {
00830         EMData * result = image->copy();
00831 
00832         float thr = params.set_default("thr",0.9);
00833         float minsegsep = params.set_default("minsegsep",5.0f);
00834         float maxsegsep = params.set_default("maxsegsep",5.1f);
00835         int verbose = params.set_default("verbose",0);
00836 
00837         vector<Pixel> pixels=image->calc_highest_locations(thr);
00838         
00839         vector<float> centers(3);       // only 1 to start
00840         int nx=image->get_xsize();
00841         int ny=image->get_ysize();
00842         int nz=image->get_zsize();
00843 //      int nxy=nx*ny;
00844 
00845         // seed the process with the highest valued point
00846         centers[0]=pixels[0].x;
00847         centers[1]=pixels[0].y;
00848         centers[2]=pixels[0].z;
00849         pixels.erase(pixels.begin());
00850         
00851         // outer loop. We add one center per iteration
00852         // This is NOT a very efficient algorithm, it assumes points are fairly sparse
00853         while (pixels.size()>0) {
00854                 // iterate over pixels until we find a new center (then stop), delete any 'bad' pixels
00855                 // no iterators because we remove elements
00856 
00857                 for (unsigned int i=0; i<pixels.size(); i++) {
00858                         
00859                         Pixel p=pixels[i];
00860                         // iterate over existing centers to see if this pixel should be removed ... technically we only should need to check the last center
00861                         for (unsigned int j=0; j<centers.size(); j+=3) {
00862                                 float d=Util::hypot3(centers[j]-p.x,centers[j+1]-p.y,centers[j+2]-p.z);
00863                                 if (d<minsegsep) {              // conflicts with existing center, erase
00864                                         pixels.erase(pixels.begin()+i);
00865                                         i--;
00866                                         break;
00867                                 }
00868                         }
00869                 }
00870                         
00871                 int found=0;
00872                 for (unsigned int i=0; i<pixels.size() && found==0; i++) {
00873                         Pixel p=pixels[i];
00874 
00875                         // iterate again to see if this may be a new valid center. Start at the end so we tend to build chains
00876                         for (unsigned int j=centers.size()-3; j>0; j-=3) {
00877                                 float d=Util::hypot3(centers[j]-p.x,centers[j+1]-p.y,centers[j+2]-p.z);
00878                                 if (d<maxsegsep) {              // we passed minsegsep question already, so we know we're in the 'good' range
00879                                         centers.push_back(p.x);
00880                                         centers.push_back(p.y);
00881                                         centers.push_back(p.z);
00882                                         pixels.erase(pixels.begin()+i); // in the centers list now, don't need it any more
00883                                         found=1;
00884                                         break;
00885                                 }
00886                         }
00887                 }
00888                 
00889                 // If we went through the whole list and didn't find one, we need to reseed again
00890                 if (!found && pixels.size()) {
00891                         if (verbose) printf("New chain\n");
00892                         centers.push_back(pixels[0].x);
00893                         centers.push_back(pixels[0].y);
00894                         centers.push_back(pixels[0].z);
00895                         pixels.erase(pixels.begin());
00896                 }
00897                 
00898                 if (verbose) printf("%d points found\n",(int)(centers.size()/3));
00899         }
00900 
00901         // after we have our list of centers classify pixels
00902         for (int z=0; z<nz; z++) {
00903                 for (int y=0; y<ny; y++) {
00904                         for (int x=0; x<nz; x++) {
00905                                 if (image->get_value_at(x,y,z)<thr) {
00906                                         result->set_value_at(x,y,z,-1.0);               //below threshold -> -1 (unclassified)
00907                                         continue;
00908                                 }
00909                                 int bcls=-1;                    // best matching class
00910                                 float bdist=(float)(nx+ny+nz);  // distance for best class
00911                                 for (unsigned int c=0; c<centers.size()/3; c++) {
00912                                         float d=Util::hypot3(x-centers[c*3],y-centers[c*3+1],z-centers[c*3+2]);
00913                                         if (d<bdist) { bdist=d; bcls=c; }
00914                                 }
00915                                 result->set_value_at(x,y,z,(float)bcls);                // set the pixel to the class number
00916                         }
00917                 }
00918         }
00919 
00920         result->set_attr("segment_centers",centers);
00921 
00922         return result;
00923 }

void DistanceSegmentProcessor::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 821 of file processor.cpp.

00822 {
00823         printf("Process inplace not implemented. Please use process.\n");
00824         return;
00825 }


Member Data Documentation

const string DistanceSegmentProcessor::NAME = "segment.distance" [static]
 

Definition at line 710 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Mon Jul 19 13:06:23 2010 for EMAN2 by  doxygen 1.4.4