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

01399                         {
01400                                 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.";
01401                         }

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

01385                         {
01386                                 return NAME;
01387                         }

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

Definition at line 1388 of file processor.h.

01389                         {
01390                                 return new Rotate180Processor();
01391                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

Definition at line 8637 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.

08637                                                       {
08638         ENTERFUNC;
08639 
08640 
08641         if (image->get_ndim() != 2) {
08642                 throw ImageDimensionException("2D only");
08643         }
08644 
08645 #ifdef EMAN2_USING_CUDA
08646         if (image->getcudarwdata()) {
08647                 emdata_rotate_180(image->getcudarwdata(), image->get_xsize(), image->get_ysize());
08648                 EXITFUNC;
08649                 return;
08650         }
08651 #endif
08652 
08653         float *d = image->get_data();
08654         int nx = image->get_xsize();
08655         int ny = image->get_ysize();
08656 
08657         // x and y offsets are used to handle even vs odd cases
08658         int x_offset = 0;
08659         if (nx % 2 == 1) x_offset=1;
08660         int y_offset = 0;
08661         if (ny % 2 == 1) y_offset=1;
08662 
08663         bool stop = false;
08664         for (int x = 1; x <= (nx/2+x_offset); x++) {
08665                 int y = 0;
08666                 for (y = 1; y < (ny+y_offset); y++) {
08667                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08668                                 stop = true;
08669                                 break;
08670                         }
08671                         int i = (x-x_offset) + (y-y_offset) * nx;
08672                         int k = nx - x + (ny - y) * nx;
08673 
08674                         float t = d[i];
08675                         d[i] = d[k];
08676                         d[k] = t;
08677                 }
08678                 if (stop) break;
08679         }
08680 
08681         /* Here we guard against irregularites that occur at the boundaries
08682          * of even dimensioned images. The basic policy is to replace the pixel
08683          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08684          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08685          * are even. FIXME - it may be better to use an average at the corner, in
08686          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08687         */
08688         if (x_offset == 0) {
08689                 for (int y = 0; y < ny; y++) {
08690                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08691                 }
08692         }
08693 
08694         if (y_offset == 0) {
08695                 for (int x = 0; x < nx; x++) {
08696                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08697                 }
08698         }
08699 
08700         if (y_offset == 0 && x_offset == 0) {
08701                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08702         }
08703 
08704         image->update();
08705         EXITFUNC;
08706 }


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 Mon May 2 13:30:01 2011 for EMAN2 by  doxygen 1.3.9.1