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

EMAN::Rotate180Processor Class Reference
[a function or class that is CUDA enabled]

Rotate by 180 using pixel swapping, works for 2D only. More...

#include <processor.h>

Inheritance diagram for EMAN::Rotate180Processor:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

string get_name () const
 Get the processor's name.
void process_inplace (EMData *image)
string get_desc () const
 Get the descrition of this specific processor.

Static Public Member Functions

ProcessorNEW ()

Static Public Attributes

const string NAME = "math.rotate.180"

Detailed Description

Rotate by 180 using pixel swapping, works for 2D only.

Author:
David Woolford
Date:
July 29th 2008

Definition at line 1480 of file processor.h.


Member Function Documentation

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

01498                         {
01499                                 return "The 2D image is rotated by 180 degree by carefully swapping image pixel values. No explicit matrix multiplication is performed. If image dimensions are even will change pixels along x=0 and y=0. Works for all combinations of even and oddness.";
01500                         }

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

01484                         {
01485                                 return NAME;
01486                         }

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

Definition at line 1487 of file processor.h.

01488                         {
01489                                 return new Rotate180Processor();
01490                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

Definition at line 8841 of file processor.cpp.

References emdata_rotate_180(), EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), ImageDimensionException, nx, ny, EMAN::EMData::set_value_at_fast(), t, EMAN::EMData::update(), x, and y.

08841                                                       {
08842         ENTERFUNC;
08843 
08844 
08845         if (image->get_ndim() != 2) {
08846                 throw ImageDimensionException("2D only");
08847         }
08848 
08849 #ifdef EMAN2_USING_CUDA
08850         if (EMData::usecuda == 1 && image->getcudarwdata()) {
08851                 //cout << "CUDA rotate 180" << endl;
08852                 emdata_rotate_180(image->getcudarwdata(), image->get_xsize(), image->get_ysize());
08853                 EXITFUNC;
08854                 return;
08855         }
08856 #endif
08857 
08858         float *d = image->get_data();
08859         int nx = image->get_xsize();
08860         int ny = image->get_ysize();
08861 
08862         // x and y offsets are used to handle even vs odd cases
08863         int x_offset = 0;
08864         if (nx % 2 == 1) x_offset=1;
08865         int y_offset = 0;
08866         if (ny % 2 == 1) y_offset=1;
08867 
08868         bool stop = false;
08869         for (int x = 1; x <= (nx/2+x_offset); x++) {
08870                 int y = 0;
08871                 for (y = 1; y < (ny+y_offset); y++) {
08872                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08873                                 stop = true;
08874                                 break;
08875                         }
08876                         int i = (x-x_offset) + (y-y_offset) * nx;
08877                         int k = nx - x + (ny - y) * nx;
08878 
08879                         float t = d[i];
08880                         d[i] = d[k];
08881                         d[k] = t;
08882                 }
08883                 if (stop) break;
08884         }
08885 
08886         /* Here we guard against irregularites that occur at the boundaries
08887          * of even dimensioned images. The basic policy is to replace the pixel
08888          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08889          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08890          * are even. FIXME - it may be better to use an average at the corner, in
08891          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08892         */
08893         if (x_offset == 0) {
08894                 for (int y = 0; y < ny; y++) {
08895                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08896                 }
08897         }
08898 
08899         if (y_offset == 0) {
08900                 for (int x = 0; x < nx; x++) {
08901                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08902                 }
08903         }
08904 
08905         if (y_offset == 0 && x_offset == 0) {
08906                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08907         }
08908 
08909         image->update();
08910         EXITFUNC;
08911 }


Member Data Documentation

const string Rotate180Processor::NAME = "math.rotate.180" [static]
 

Definition at line 85 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Fri Aug 10 16:37:06 2012 for EMAN2 by  doxygen 1.3.9.1