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:

[legend]
Collaboration diagram for EMAN::TestImageEllipse:
[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 = "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 6318 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 6328 of file processor.h.

06329                 {
06330                         return "Insert an ellipse into the image.";
06331                 }

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

06324                 {
06325                         return NAME;
06326                 }

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

References EMAN::TypeDict::put().

06339                 {
06340                         TypeDict d;
06341                         d.put("a", EMObject::FLOAT, "equatorial radii along x axes");
06342                         d.put("b", EMObject::FLOAT, "equatorial radii along y axes");
06343                         d.put("c", EMObject::FLOAT, "polar radius");
06344                         d.put("transform", EMObject::TRANSFORM, "Optionally transform the ellipse");
06345                         d.put("fill", EMObject::FLOAT, "value you want to fill in ellipse, default to 1.0");
06346                         return d;
06347                 }

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

Definition at line 6333 of file processor.h.

06334                 {
06335                         return new TestImageEllipse();
06336                 }

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 7557 of file processor.cpp.

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

07558 {
07559         preprocess(image);
07560 
07561 
07562         float a = params.set_default("a",nx/2.0f-1.0f);
07563         float b = params.set_default("b",ny/2.0f-1.0f);
07564         float c = params.set_default("c",nz/2.0f-1.0f);
07565         float fill = params.set_default("fill",1.0f);
07566         //bool hollow = params.set_default("hollow",false);
07567         Transform* t;
07568         if (params.has_key("transform")) {
07569                 t = params["transform"];
07570         } else {
07571                 t = new Transform;
07572         }
07573 
07574 
07575         int mz = 2*(int)c+1;
07576         if ( nz < mz ) mz = nz;
07577         int my = 2*(int)b+1;
07578         if ( ny < my ) my = ny;
07579         int mx = 2*(int)a+1;
07580         if ( nx < mx ) mx = nx;
07581 
07582 
07583         float ai = 1/(a*a);
07584         float bi = 1/(b*b);
07585         float ci = 1/(c*c);
07586 
07587         Vec3f origin(nx/2,ny/2,nz/2);
07588 
07589         float x2, y2, z2, r;
07590         int xl, yl, zl;
07591         for (int k = 0; k < mz; ++k) {
07592                 for (int j = 0; j < my; ++j) {
07593                         for (int i = 0; i < mx; ++i) {
07594                                 x2 = (float)(i - mx/2);
07595                                 y2 = (float)(j - my/2);
07596                                 z2 = (float)(k - mz/2);
07597                                 r = (x2*x2)*ai + (y2*y2)*bi + (z2*z2)*ci;
07598                                 if (r <= 1) {
07599 
07600                                         if (t != 0) {
07601                                                 Vec3f v(x2,y2,z2);
07602                                                 v = (*t)*v;
07603                                                 v += origin;
07604 
07605                                                 // THIS ISN'T THE BEST STRATEGY BUT IT'S A STOP GAP. A FLOOD FILL IS PROBABLY BETTER
07606                                                 // I fill in 3x3 cubes to make sure there are no gaps...
07607 
07608                                                 for( int kk = -1; kk <= 1; ++kk)
07609                                                         for( int jj = -1; jj <= 1; ++jj)
07610                                                                 for( int ii = -1; ii <= 1; ++ii) {
07611                                                                         xl = (int)v[0]+ii;
07612                                                                         yl = (int)v[1]+jj;
07613                                                                         zl = (int)v[2]+kk;
07614                                                                         if (xl >= 0 && xl < nx && yl >= 0 && yl < ny && zl >= 0 && zl < nz)
07615                                                                                 image->set_value_at(xl,yl,zl,fill);
07616                                                                 }
07617                                         } else {
07618                                                 image->set_value_at((int)x2+nx/2,(int)y2+ny/2,(int)z2+nz/2,fill);
07619                                         }
07620                                 }
07621                         }
07622                 }
07623         }
07624 
07625         delete t;
07626 
07627         image->update();
07628 }


Member Data Documentation

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

Definition at line 204 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Fri Apr 30 15:39:28 2010 for EMAN2 by  doxygen 1.3.9.1