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 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.

References NAME.

01484                         {
01485                                 return NAME;
01486                         }

static 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 8906 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.

08906                                                       {
08907         ENTERFUNC;
08908 
08909 
08910         if (image->get_ndim() != 2) {
08911                 throw ImageDimensionException("2D only");
08912         }
08913 
08914 #ifdef EMAN2_USING_CUDA
08915         if (EMData::usecuda == 1 && image->getcudarwdata()) {
08916                 //cout << "CUDA rotate 180" << endl;
08917                 emdata_rotate_180(image->getcudarwdata(), image->get_xsize(), image->get_ysize());
08918                 EXITFUNC;
08919                 return;
08920         }
08921 #endif
08922 
08923         float *d = image->get_data();
08924         int nx = image->get_xsize();
08925         int ny = image->get_ysize();
08926 
08927         // x and y offsets are used to handle even vs odd cases
08928         int x_offset = 0;
08929         if (nx % 2 == 1) x_offset=1;
08930         int y_offset = 0;
08931         if (ny % 2 == 1) y_offset=1;
08932 
08933         bool stop = false;
08934         for (int x = 1; x <= (nx/2+x_offset); x++) {
08935                 int y = 0;
08936                 for (y = 1; y < (ny+y_offset); y++) {
08937                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08938                                 stop = true;
08939                                 break;
08940                         }
08941                         int i = (x-x_offset) + (y-y_offset) * nx;
08942                         int k = nx - x + (ny - y) * nx;
08943 
08944                         float t = d[i];
08945                         d[i] = d[k];
08946                         d[k] = t;
08947                 }
08948                 if (stop) break;
08949         }
08950 
08951         /* Here we guard against irregularites that occur at the boundaries
08952          * of even dimensioned images. The basic policy is to replace the pixel
08953          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08954          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08955          * are even. FIXME - it may be better to use an average at the corner, in
08956          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08957         */
08958         if (x_offset == 0) {
08959                 for (int y = 0; y < ny; y++) {
08960                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08961                 }
08962         }
08963 
08964         if (y_offset == 0) {
08965                 for (int x = 0; x < nx; x++) {
08966                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08967                 }
08968         }
08969 
08970         if (y_offset == 0 && x_offset == 0) {
08971                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08972         }
08973 
08974         image->update();
08975         EXITFUNC;
08976 }


Member Data Documentation

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

Definition at line 1502 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 12:43:39 2013 for EMAN2 by  doxygen 1.4.7