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

01303                         {
01304                                 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.";
01305                         }

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

01289                         {
01290                                 return NAME;
01291                         }

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

Definition at line 1292 of file processor.h.

01293                         {
01294                                 return new Rotate180Processor();
01295                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

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

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


Member Data Documentation

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

Definition at line 83 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Mon Mar 7 18:17:23 2011 for EMAN2 by  doxygen 1.3.9.1