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

EMAN::TestImageEllipse Class Reference

Generate an ellipse or ellipsoid image. More...

#include <processor.h>

Inheritance diagram for EMAN::TestImageEllipse:

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

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 = "testimage.ellipsoid"

Detailed Description

Generate an ellipse or ellipsoid image.

Parameters:
a equatorial radii along x axes
b equatorial radii along y axes
c polar radius
transform Optionally transform the ellipse
fill value you want to fill in ellipse, default to 1.0

Definition at line 6359 of file processor.h.


Member Function Documentation

virtual string EMAN::TestImageEllipse::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 6369 of file processor.h.

06370                 {
06371                         return "Insert an ellipse into the image.";
06372                 }

virtual string EMAN::TestImageEllipse::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 6364 of file processor.h.

References NAME.

06365                 {
06366                         return NAME;
06367                 }

virtual TypeDict EMAN::TestImageEllipse::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 6379 of file processor.h.

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

06380                 {
06381                         TypeDict d;
06382                         d.put("a", EMObject::FLOAT, "equatorial radii along x axes");
06383                         d.put("b", EMObject::FLOAT, "equatorial radii along y axes");
06384                         d.put("c", EMObject::FLOAT, "polar radius");
06385                         d.put("transform", EMObject::TRANSFORM, "Optionally transform the ellipse");
06386                         d.put("fill", EMObject::FLOAT, "value you want to fill in ellipse, default to 1.0");
06387                         return d;
06388                 }

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

Definition at line 6374 of file processor.h.

06375                 {
06376                         return new TestImageEllipse();
06377                 }

void TestImageEllipse::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 7695 of file processor.cpp.

References b, bi, EMAN::Dict::has_key(), EMAN::Processor::params, EMAN::TestImageProcessor::preprocess(), EMAN::Dict::set_default(), EMAN::EMData::set_value_at(), t, EMAN::EMData::update(), and v.

07696 {
07697         preprocess(image);
07698 
07699 
07700         float a = params.set_default("a",nx/2.0f-1.0f);
07701         float b = params.set_default("b",ny/2.0f-1.0f);
07702         float c = params.set_default("c",nz/2.0f-1.0f);
07703         float fill = params.set_default("fill",1.0f);
07704         //bool hollow = params.set_default("hollow",false);
07705         Transform* t;
07706         if (params.has_key("transform")) {
07707                 t = params["transform"];
07708         } else {
07709                 t = new Transform;
07710         }
07711 
07712 
07713         int mz = 2*(int)c+1;
07714         if ( nz < mz ) mz = nz;
07715         int my = 2*(int)b+1;
07716         if ( ny < my ) my = ny;
07717         int mx = 2*(int)a+1;
07718         if ( nx < mx ) mx = nx;
07719 
07720 
07721         float ai = 1/(a*a);
07722         float bi = 1/(b*b);
07723         float ci = 1/(c*c);
07724 
07725         Vec3f origin(nx/2,ny/2,nz/2);
07726 
07727         float x2, y2, z2, r;
07728         int xl, yl, zl;
07729         for (int k = 0; k < mz; ++k) {
07730                 for (int j = 0; j < my; ++j) {
07731                         for (int i = 0; i < mx; ++i) {
07732                                 x2 = (float)(i - mx/2);
07733                                 y2 = (float)(j - my/2);
07734                                 z2 = (float)(k - mz/2);
07735                                 r = (x2*x2)*ai + (y2*y2)*bi + (z2*z2)*ci;
07736                                 if (r <= 1) {
07737 
07738                                         if (t != 0) {
07739                                                 Vec3f v(x2,y2,z2);
07740                                                 v = (*t)*v;
07741                                                 v += origin;
07742 
07743                                                 // THIS ISN'T THE BEST STRATEGY BUT IT'S A STOP GAP. A FLOOD FILL IS PROBABLY BETTER
07744                                                 // I fill in 3x3 cubes to make sure there are no gaps...
07745 
07746                                                 for( int kk = -1; kk <= 1; ++kk)
07747                                                         for( int jj = -1; jj <= 1; ++jj)
07748                                                                 for( int ii = -1; ii <= 1; ++ii) {
07749                                                                         xl = (int)v[0]+ii;
07750                                                                         yl = (int)v[1]+jj;
07751                                                                         zl = (int)v[2]+kk;
07752                                                                         if (xl >= 0 && xl < nx && yl >= 0 && yl < ny && zl >= 0 && zl < nz)
07753                                                                                 image->set_value_at(xl,yl,zl,fill);
07754                                                                 }
07755                                         } else {
07756                                                 image->set_value_at((int)x2+nx/2,(int)y2+ny/2,(int)z2+nz/2,fill);
07757                                         }
07758                                 }
07759                         }
07760                 }
07761         }
07762 
07763         delete t;
07764 
07765         image->update();
07766 }


Member Data Documentation

const string TestImageEllipse::NAME = "testimage.ellipsoid" [static]
 

Definition at line 6390 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:07:25 2010 for EMAN2 by  doxygen 1.4.4