Translates a cornered image to the center Undoes the PhaseToCornerProcessor. More...

#include <processor.h>

Inheritance diagram for EMAN::PhaseToCenterProcessor:

Collaboration diagram for EMAN::PhaseToCenterProcessor:

[legend]

Public Member Functions
virtual void	process_inplace (EMData *image)
	To process an image in-place. More...

virtual string	get_name () const
	Get the processor's name. More...

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

Public Member Functions inherited from EMAN::Processor
virtual	~Processor ()

virtual EMData *	process (const EMData *const image)
	To proccess an image out-of-place. More...

virtual void	process_list_inplace (vector< EMData * > &images)
	To process multiple images using the same algorithm. More...

virtual Dict	get_params () const
	Get the processor parameters in a key/value dictionary. More...

virtual void	set_params (const Dict &new_params)
	Set the processor parameters using a key/value dictionary. More...

virtual TypeDict	get_param_types () const
	Get processor parameter information in a dictionary. More...

Static Public Member Functions
static Processor *	NEW ()

Static Public Member Functions inherited from EMAN::Processor
static string	get_group_desc ()
	Get the description of this group of processors. More...

static void	EMFourierFilterInPlace (EMData *fimage, Dict params)
	Compute a Fourier-filter processed image in place. More...

static EMData *	EMFourierFilter (EMData *fimage, Dict params)
	Compute a Fourier-processor processed image without altering the original image. More...

Static Public Attributes
static const string	NAME = "xform.phaseorigin.tocenter"

Additional Inherited Members
Public Types inherited from EMAN::Processor
enum	fourier_filter_types { TOP_HAT_LOW_PASS , TOP_HAT_HIGH_PASS , TOP_HAT_BAND_PASS , TOP_HOMOMORPHIC , GAUSS_LOW_PASS , GAUSS_HIGH_PASS , GAUSS_BAND_PASS , GAUSS_INVERSE , GAUSS_HOMOMORPHIC , BUTTERWORTH_LOW_PASS , BUTTERWORTH_HIGH_PASS , BUTTERWORTH_HOMOMORPHIC , KAISER_I0 , KAISER_SINH , KAISER_I0_INVERSE , KAISER_SINH_INVERSE , SHIFT , TANH_LOW_PASS , TANH_HIGH_PASS , TANH_HOMOMORPHIC , TANH_BAND_PASS , RADIAL_TABLE , CTF_ }
	Fourier filter Processor type enum. More...

Protected Member Functions inherited from EMAN::Phase180Processor
void	swap_corners_180 (EMData *image)
	swap_corners_180 - works on 2D and 3D images More...

void	swap_central_slices_180 (EMData *image)
	swap_central_slices_180 - works on 2D and 3D images More...

void	fourier_phaseshift180 (EMData *image)
	fourier_phaseshift180 - fourier phase shift by 180 this function is called internally if the argument to the process_inplace function is complex. More...

Protected Attributes inherited from EMAN::Processor
Dict	params

Detailed Description

Translates a cornered image to the center Undoes the PhaseToCornerProcessor.

works for 1D, 2D and 3D images, for all combinations of even and oddness

Author: David Woolford woolf.nosp@m.ord@.nosp@m.bcm.e.nosp@m.du

Date: October 2007

Definition at line 6729 of file processor.h.

Member Function Documentation

◆ get_desc()

virtual string EMAN::PhaseToCenterProcessor::get_desc ( ) const

inlinevirtual

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

                        {
                                return "Undoes the effect of the xform.phaseorigin.tocorner processor";
                        }

◆ get_name()

virtual string EMAN::PhaseToCenterProcessor::get_name ( ) const

inlinevirtual

Get the processor's name.

Each processor is identified by a unique name.

Returns: The processor's name.

Implements EMAN::Processor.

Definition at line 6734 of file processor.h.

                        {
                                return NAME;
                        }

References NAME.

◆ NEW()

static Processor * EMAN::PhaseToCenterProcessor::NEW ( )

inlinestatic

Definition at line 6739 of file processor.h.

                        {
                                return new PhaseToCenterProcessor();
                        }

◆ process_inplace()

void PhaseToCenterProcessor::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 6550 of file processor.cpp.

{
        if (!image) throw NullPointerException("Error: attempt to phase shift a null image");
 
#ifdef EMAN2_USING_CUDA
        if (EMData::usecuda == 1 && image->getcudarwdata() && image->get_ndim() == 2) { // Because CUDA phase origin to center only works for 2D atm
                //cout << "CUDA tocenter" << endl;
                emdata_phaseorigin_to_center(image->getcudarwdata(), image->get_xsize(), image->get_ysize(), image->get_zsize());
                return;
        }
#endif // EMAN2_USING_CUDA
 
        if (image->is_complex()) {
                fourier_phaseshift180(image);
                return;
        }
 
        int nx = image->get_xsize();
        int ny = image->get_ysize();
        int nz = image->get_zsize();
 
        if ( ny == 1 && nz == 1 && nx == 1) return;
 
        int nxy = nx * ny;
 
        float *rdata = image->get_data();
 
        bool xodd = (nx % 2) == 1;
        bool yodd = (ny % 2) == 1;
        bool zodd = (nz % 2) == 1;
 
        if ( ny == 1 && nz == 1 ){
                if (xodd) {
                        // Put the center pixel at the end, shifting the contents
                        // to right of the center one step to the left
                        float in_x = rdata[nx/2];
                        float tmp;
                        for ( int i = nx-1; i >= nx/2; --i ) {
                                tmp = rdata[i];
                                rdata[i] = in_x;
                                in_x = tmp;
                        }
                }
                // now the operation is straight forward
                for ( int i = 0; i < nx/2; ++i ) {
                        int idx = i + nx/2;
                        float tmp = rdata[i];
                        rdata[i] = rdata[idx];
                        rdata[idx] = tmp;
                }
        }
        else if ( nz == 1 ){
                // The order in which these operations occur literally undoes what the
                // PhaseToCornerProcessor did to the image.
                // First, the corners sections of the image are swapped appropriately
                swap_corners_180(image);
                // Second, central pixel lines are swapped
                swap_central_slices_180(image);
 
                float tmp;
                // Third, appropriate sections of the image are cyclically shifted by one pixel
                if (xodd) {
                        // Transfer the middle column to the far right
                        // Shift all from the far right to (but not including the) middle one to the left
                        for ( int r      = 0; r < ny; ++r ) {
                                float last_val = rdata[r*nx+nx/2];
                                for ( int c = nx-1; c >=  nx/2; --c ){
                                        int idx = r*nx+c;
                                        tmp = rdata[idx];
                                        rdata[idx] = last_val;
                                        last_val = tmp;
                                }
                        }
                }
                if (yodd) {
                        // Tranfer the middle row to the top,
                        // shifting all pixels from the top row down one, until  but not including the) middle
                        for ( int c = 0; c < nx; ++c ) {
                                // Get the value in the top row
                                float last_val = rdata[ny/2*nx + c];
                                for ( int r = ny-1; r >= ny/2; --r ){
                                        int idx = r*nx+c;
                                        tmp = rdata[idx];
                                        rdata[idx] = last_val;
                                        last_val = tmp;
                                }
                        }
                }
        }
        else
        {
                // The order in which these operations occur literally undoes the
                // PhaseToCornerProcessor operation - in 3D.
                // First, the corner quadrants of the voxel volume are swapped
                swap_corners_180(image);
                // Second, appropriate parts of the central slices are swapped
                swap_central_slices_180(image);
 
                float tmp;
                // Third, appropriate sections of the image are cyclically shifted by one voxel
                if (xodd) {
                        // Transfer the central slice in the x direction to the far right
                        // moving all slices on the far right toward the center one pixel, until
                        // the center x slice is ecountered
                        size_t idx = 0;
                        for (int s = 0; s < nz; ++s) {
                                for (int r = 0; r < ny; ++r) {
                                        float last_val = rdata[s*nxy+r*nx+nx/2];
                                        for (int c = nx-1; c >= nx/2; --c){
                                                idx = (size_t)s*nxy+r*nx+c;
                                                tmp = rdata[idx];
                                                rdata[idx] = last_val;
                                                last_val = tmp;
                                        }
                                }
                        }
                }
                if (yodd) {
                        // Tranfer the central slice in the y direction to the top
                        // shifting all pixels below it down on, until the center y slice is encountered.
                        size_t idx = 0;
                        for (int s = 0; s < nz; ++s) {
                                for (int c = 0; c < nx; ++c) {
                                        float last_val = rdata[s*nxy+ny/2*nx+c];
                                        for (int r = ny-1; r >= ny/2; --r){
                                                idx = (size_t)s*nxy+r*nx+c;
                                                tmp = rdata[idx];
                                                rdata[idx] = last_val;
                                                last_val = tmp;
                                        }
                                }
                        }
                }
                if (zodd) {
                        // Tranfer the central slice in the z direction to the back
                        // shifting all pixels beyond and including the middle slice back one.
                        size_t idx = 0;
                        for (int r = 0; r < ny; ++r){
                                for (int c = 0; c < nx; ++c) {
                                        float last_val = rdata[nz/2*nxy+r*nx+c];
                                        for (int s = nz-1; s >= nz/2; --s) {
                                                idx = (size_t)s*nxy+r*nx+c;
                                                tmp = rdata[idx];
                                                rdata[idx] = last_val;
                                                last_val = tmp;
                                        }
                                }
                        }
                }
        }
}

References emdata_phaseorigin_to_center(), EMAN::Phase180Processor::fourier_phaseshift180(), NullPointerException, rdata, EMAN::Phase180Processor::swap_central_slices_180(), and EMAN::Phase180Processor::swap_corners_180().

Member Data Documentation

◆ NAME

const string PhaseToCenterProcessor::NAME = "xform.phaseorigin.tocenter"

static

Definition at line 6749 of file processor.h.

Referenced by get_name().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ get_desc()

◆ get_name()

◆ NEW()

◆ process_inplace()

Member Data Documentation

◆ NAME