Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

EMAN::PhaseToCornerProcessor Class Reference
[unit test in Python]

Translates a centered image to the corner works for 1D, 2D and 3D images, for all combinations of even and oddness. More...

#include <processor.h>

Inheritance diagram for EMAN::PhaseToCornerProcessor:

Inheritance graph
[legend]
Collaboration diagram for EMAN::PhaseToCornerProcessor:

Collaboration graph
[legend]
List of all members.

Public Member Functions

virtual void process_inplace (EMData *image)
 To process an image in-place.
virtual string get_name () const
 Get the processor's name.
virtual string get_desc () const
 Get the descrition of this specific processor.

Static Public Member Functions

ProcessorNEW ()

Static Public Attributes

const string NAME = "xform.phaseorigin.tocorner"

Detailed Description

Translates a centered image to the corner works for 1D, 2D and 3D images, for all combinations of even and oddness.

Author:
David Woolford <woolford@bcm.edu>
Date:
October 2007

Definition at line 4795 of file processor.h.


Member Function Documentation

virtual string EMAN::PhaseToCornerProcessor::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 4810 of file processor.h.

04811                         {
04812                                 return "Translates a centered image to the corner in a forward fashion";
04813                         }

virtual string EMAN::PhaseToCornerProcessor::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 4800 of file processor.h.

04801                         {
04802                                 return NAME;
04803                         }

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

Definition at line 4805 of file processor.h.

04806                         {
04807                                 return new PhaseToCornerProcessor();
04808                         }

void PhaseToCornerProcessor::process_inplace EMData image  )  [virtual]
 

To process an image in-place.

For those processors which can only be processed out-of-place, override this function to just print out some error message to remind user call the out-of-place version.

Parameters:
image The image to be processed.

Implements EMAN::Processor.

Definition at line 4926 of file processor.cpp.

References emdata_phaseorigin_to_corner(), EMAN::Phase180Processor::fourier_phaseshift180(), EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::is_complex(), NullPointerException, nx, ny, rdata, EMAN::Phase180Processor::swap_central_slices_180(), and EMAN::Phase180Processor::swap_corners_180().

04927 {
04928         if (!image)     throw NullPointerException("Error: attempt to phase shift a null image");
04929 
04930 #ifdef EMAN2_USING_CUDA
04931         if (image->getcudarwdata() && image->get_ndim() == 2) { // Because CUDA phase origin to center only works for 2D atm
04932                 //cout << "CUDA tocorner" << endl;
04933                 emdata_phaseorigin_to_corner(image->getcudarwdata(), image->get_xsize(), image->get_ysize(), image->get_zsize());
04934                 return;
04935         }
04936 #endif // EMAN2_USING_CUDA
04937 
04938         if (image->is_complex()) {
04939                 fourier_phaseshift180(image);
04940                 return;
04941         }
04942 
04943         int nx = image->get_xsize();
04944         int ny = image->get_ysize();
04945         int nz = image->get_zsize();
04946 
04947         if ( ny == 1 && nz == 1 && nx == 1) return;
04948 
04949         int nxy = nx * ny;
04950 
04951         float *rdata = image->get_data();
04952 
04953         bool xodd = (nx % 2) == 1;
04954         bool yodd = (ny % 2) == 1;
04955         bool zodd = (nz % 2) == 1;
04956 
04957         if ( ny == 1 && nz == 1 ){
04958                 if (xodd){
04959                         // Put the last pixel in the center, shifting the contents
04960                         // to right of the center one step to the right
04961                         float in_x = rdata[nx-1];
04962                         float tmp;
04963                         for ( int i = nx/2; i < nx; ++i ) {
04964                                 tmp = rdata[i];
04965                                 rdata[i] = in_x;
04966                                 in_x = tmp;
04967                         }
04968                 }
04969                 // now the operation is straight forward
04970                 for ( int i = 0; i < nx/2; ++i ) {
04971                         int idx = i+nx/2+xodd;
04972                         float tmp = rdata[i];
04973                         rdata[i] = rdata[idx];
04974                         rdata[idx] = tmp;
04975                 }
04976 
04977         }
04978         else if ( nz == 1 ) {
04979                 if (yodd) {
04980                         // Tranfer the top row into the middle row,
04981                         // shifting all pixels above and including the current middle up one.
04982                         for ( int c = 0; c < nx; ++c ) {
04983                                 // Get the value in the top row
04984                                 float last_val = rdata[(ny-1)*nx + c];
04985                                 float tmp;
04986                                 for ( int r = ny/2; r < ny; ++r ){
04987                                         int idx =r*nx+c;
04988                                         tmp = rdata[idx];
04989                                         rdata[idx] = last_val;
04990                                         last_val = tmp;
04991                                 }
04992                         }
04993                 }
04994 
04995                 if (xodd) {
04996                         // Transfer the right most column into the center column
04997                         // Shift all columns right of and including center to the right one pixel
04998                         for ( int r  = 0; r < ny; ++r ) {
04999                                 float last_val = rdata[(r+1)*nx -1];
05000                                 float tmp;
05001                                 for ( int c = nx/2; c < nx; ++c ){
05002                                         int idx =r*nx+c;
05003                                         tmp = rdata[idx];
05004                                         rdata[idx] = last_val;
05005                                         last_val = tmp;
05006                                 }
05007                         }
05008                 }
05009                 // It is important central slice shifting come after the previous two operations
05010                 swap_central_slices_180(image);
05011                 // Now the corners of the image can be shifted...
05012                 swap_corners_180(image);
05013 
05014         }
05015         else
05016         {
05017                 float tmp;
05018                 if (zodd) {
05019                         // Tranfer the back slice into the middle slice,
05020                         // shifting all pixels beyond and including the middle slice back one.
05021                         size_t idx = 0;
05022                         for (int r = 0; r < ny; ++r){
05023                                 for (int c = 0; c < nx; ++c) {
05024                                         float last_val = rdata[(nz-1)*nxy+r*nx+c];
05025                                         for (int s = nz/2; s < nz; ++s) {
05026                                                 idx = (size_t)s*nxy+r*nx+c;
05027                                                 tmp = rdata[idx];
05028                                                 rdata[idx] = last_val;
05029                                                 last_val = tmp;
05030                                         }
05031                                 }
05032                         }
05033                 }
05034                 if (yodd) {
05035                         // Tranfer the top slice into the middle slice,
05036                         // shifting all pixels above and including the middle slice up one.
05037                         size_t idx = 0;
05038                         for (int s = 0; s < nz; ++s) {
05039                                 for (int c = 0; c < nx; ++c) {
05040                                 float last_val = rdata[s*nxy+(ny-1)*nx+c];
05041                                         for (int r = ny/2; r < ny; ++r){
05042                                                 idx = (size_t)s*nxy+r*nx+c;
05043                                                 tmp = rdata[idx];
05044                                                 rdata[idx] = last_val;
05045                                                 last_val = tmp;
05046                                         }
05047                                 }
05048                         }
05049                 }
05050                 if (xodd) {
05051                         // Transfer the right most slice into the central slice
05052                         // Shift all pixels to right of and including center slice to the right one pixel
05053                         size_t idx = 0;
05054                         for (int s = 0; s < nz; ++s) {
05055                                 for (int r = 0; r < ny; ++r) {
05056                                         float last_val = rdata[s*nxy+r*nx+nx-1];
05057                                         for (int c = nx/2; c < nx; ++c){
05058                                                 idx = (size_t)s*nxy+r*nx+c;
05059                                                 tmp = rdata[idx];
05060                                                 rdata[idx] = last_val;
05061                                                 last_val = tmp;
05062                                         }
05063                                 }
05064                         }
05065                 }
05066                 // Now swap the various parts in the central slices
05067                 swap_central_slices_180(image);
05068                 // Now shift the corners
05069                 swap_corners_180(image);
05070         }
05071 }


Member Data Documentation

const string PhaseToCornerProcessor::NAME = "xform.phaseorigin.tocorner" [static]
 

Definition at line 164 of file processor.cpp.


The documentation for this class was generated from the following files:
Generated on Mon May 2 13:30:36 2011 for EMAN2 by  doxygen 1.3.9.1