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

01453                         {
01454                                 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.";
01455                         }

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

01439                         {
01440                                 return NAME;
01441                         }

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

Definition at line 1442 of file processor.h.

01443                         {
01444                                 return new Rotate180Processor();
01445                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

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

08754                                                       {
08755         ENTERFUNC;
08756 
08757 
08758         if (image->get_ndim() != 2) {
08759                 throw ImageDimensionException("2D only");
08760         }
08761 
08762 #ifdef EMAN2_USING_CUDA
08763         if (EMData::usecuda == 1 && image->getcudarwdata()) {
08764                 //cout << "CUDA rotate 180" << endl;
08765                 emdata_rotate_180(image->getcudarwdata(), image->get_xsize(), image->get_ysize());
08766                 EXITFUNC;
08767                 return;
08768         }
08769 #endif
08770 
08771         float *d = image->get_data();
08772         int nx = image->get_xsize();
08773         int ny = image->get_ysize();
08774 
08775         // x and y offsets are used to handle even vs odd cases
08776         int x_offset = 0;
08777         if (nx % 2 == 1) x_offset=1;
08778         int y_offset = 0;
08779         if (ny % 2 == 1) y_offset=1;
08780 
08781         bool stop = false;
08782         for (int x = 1; x <= (nx/2+x_offset); x++) {
08783                 int y = 0;
08784                 for (y = 1; y < (ny+y_offset); y++) {
08785                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08786                                 stop = true;
08787                                 break;
08788                         }
08789                         int i = (x-x_offset) + (y-y_offset) * nx;
08790                         int k = nx - x + (ny - y) * nx;
08791 
08792                         float t = d[i];
08793                         d[i] = d[k];
08794                         d[k] = t;
08795                 }
08796                 if (stop) break;
08797         }
08798 
08799         /* Here we guard against irregularites that occur at the boundaries
08800          * of even dimensioned images. The basic policy is to replace the pixel
08801          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08802          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08803          * are even. FIXME - it may be better to use an average at the corner, in
08804          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08805         */
08806         if (x_offset == 0) {
08807                 for (int y = 0; y < ny; y++) {
08808                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08809                 }
08810         }
08811 
08812         if (y_offset == 0) {
08813                 for (int x = 0; x < nx; x++) {
08814                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08815                 }
08816         }
08817 
08818         if (y_offset == 0 && x_offset == 0) {
08819                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08820         }
08821 
08822         image->update();
08823         EXITFUNC;
08824 }


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 Thu Nov 17 12:45:55 2011 for EMAN2 by  doxygen 1.3.9.1