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

01485                         {
01486                                 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.";
01487                         }

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

References NAME.

01471                         {
01472                                 return NAME;
01473                         }

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

Definition at line 1474 of file processor.h.

01475                         {
01476                                 return new Rotate180Processor();
01477                         }

void Rotate180Processor::process_inplace EMData image  )  [virtual]
 

Exceptions:
ImageDimensionException if the image dimensions are not 2D

Implements EMAN::Processor.

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

08573                                                       {
08574         ENTERFUNC;
08575 
08576 
08577         if (image->get_ndim() != 2) {
08578                 throw ImageDimensionException("2D only");
08579         }
08580 
08581 #ifdef EMAN2_USING_CUDA
08582         if (image->gpu_operation_preferred() ) {
08583                 EMDataForCuda tmp = image->get_data_struct_for_cuda();
08584                 emdata_rotate_180(&tmp);
08585                 image->gpu_update();
08586                 EXITFUNC;
08587                 return;
08588         }
08589 #endif
08590 
08591         float *d = image->get_data();
08592         int nx = image->get_xsize();
08593         int ny = image->get_ysize();
08594 
08595         // x and y offsets are used to handle even vs odd cases
08596         int x_offset = 0;
08597         if (nx % 2 == 1) x_offset=1;
08598         int y_offset = 0;
08599         if (ny % 2 == 1) y_offset=1;
08600 
08601         bool stop = false;
08602         for (int x = 1; x <= (nx/2+x_offset); x++) {
08603                 int y = 0;
08604                 for (y = 1; y < (ny+y_offset); y++) {
08605                         if (x == (nx / 2+x_offset) && y == (ny / 2+y_offset)) {
08606                                 stop = true;
08607                                 break;
08608                         }
08609                         int i = (x-x_offset) + (y-y_offset) * nx;
08610                         int k = nx - x + (ny - y) * nx;
08611 
08612                         float t = d[i];
08613                         d[i] = d[k];
08614                         d[k] = t;
08615                 }
08616                 if (stop) break;
08617         }
08618 
08619         /* Here we guard against irregularites that occur at the boundaries
08620          * of even dimensioned images. The basic policy is to replace the pixel
08621          * in row 0 and/or column 0 with those in row 1 and/or column 1, respectively.
08622          * The pixel at 0,0 is replaced with the pixel at 1,1 if both image dimensions
08623          * are even. FIXME - it may be better to use an average at the corner, in
08624          * this latter case, using pixels (1,1), (0,1) and (1,0). I am not sure. (dsawoolford)
08625         */
08626         if (x_offset == 0) {
08627                 for (int y = 0; y < ny; y++) {
08628                         image->set_value_at_fast(0,y,image->get_value_at(1,y));
08629                 }
08630         }
08631 
08632         if (y_offset == 0) {
08633                 for (int x = 0; x < nx; x++) {
08634                         image->set_value_at_fast(x,0,image->get_value_at(x,1));
08635                 }
08636         }
08637 
08638         if (y_offset == 0 && x_offset == 0) {
08639                 image->set_value_at_fast(0,0,image->get_value_at(1,1));
08640         }
08641 
08642         image->update();
08643         EXITFUNC;
08644 }


Member Data Documentation

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

Definition at line 1489 of file processor.h.

Referenced by get_name().


The documentation for this class was generated from the following files:
Generated on Tue May 25 17:36:59 2010 for EMAN2 by  doxygen 1.4.4