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)
 
Exceptions:
ImageDimensionException if the image dimensions are not 2D

string get_desc () const
 Get the descrition of this specific processor.

Static Public Member Functions

static ProcessorNEW ()

Static Public Attributes

static 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 1507 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 1524 of file processor.h.

01525                         {
01526                                 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.";
01527                         }

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

References NAME.

01511                         {
01512                                 return NAME;
01513                         }

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

Definition at line 1514 of file processor.h.

01515                         {
01516                                 return new Rotate180Processor();
01517                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

Definition at line 8680 of file processor.cpp.

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

08680                                                       {
08681         ENTERFUNC;
08682 
08683 
08684         if (image->get_ndim() != 2) {
08685                 throw ImageDimensionException("2D only");
08686         }
08687 
08688 #ifdef EMAN2_USING_CUDA
08689         if (image->gpu_operation_preferred() ) {
08690                 EMDataForCuda tmp = image->get_data_struct_for_cuda();
08691                 emdata_rotate_180(&tmp);
08692                 image->gpu_update();
08693                 EXITFUNC;
08694                 return;
08695         }
08696 #endif
08697 
08698         float *d = image->get_data();
08699         int nx = image->get_xsize();
08700         int ny = image->get_ysize();
08701 
08702         // x and y offsets are used to handle even vs odd cases
08703         int x_offset = 0;
08704         if (nx % 2 == 1) x_offset=1;
08705         int y_offset = 0;
08706         if (ny % 2 == 1) y_offset=1;
08707 
08708         bool stop = false;
08709         for (int x = 1; x <= (nx/2+x_offset); x++) {
08710                 int y = 0;
08711                 for (y = 1; y < (ny+y_offset); y++) {
08712                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08713                                 stop = true;
08714                                 break;
08715                         }
08716                         int i = (x-x_offset) + (y-y_offset) * nx;
08717                         int k = nx - x + (ny - y) * nx;
08718 
08719                         float t = d[i];
08720                         d[i] = d[k];
08721                         d[k] = t;
08722                 }
08723                 if (stop) break;
08724         }
08725 
08726         /* Here we guard against irregularites that occur at the boundaries
08727          * of even dimensioned images. The basic policy is to replace the pixel
08728          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08729          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08730          * are even. FIXME - it may be better to use an average at the corner, in
08731          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08732         */
08733         if (x_offset == 0) {
08734                 for (int y = 0; y < ny; y++) {
08735                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08736                 }
08737         }
08738 
08739         if (y_offset == 0) {
08740                 for (int x = 0; x < nx; x++) {
08741                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08742                 }
08743         }
08744 
08745         if (y_offset == 0 && x_offset == 0) {
08746                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08747         }
08748 
08749         image->update();
08750         EXITFUNC;
08751 }


Member Data Documentation

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

Definition at line 1529 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:06:34 2010 for EMAN2 by  doxygen 1.4.4